Skip to main content
aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authoracuccuru2012-04-13 12:38:54 +0000
committeracuccuru2012-04-13 12:38:54 +0000
commit337bb859fc30dc7809864ca115f79b556ee4607f (patch)
treeaa133888e30f102b8951ba83ac5e50aa6411aaae
parentda6fbde92336f28aac29782d3dc62abadcdbd8eb (diff)
downloadorg.eclipse.papyrus-337bb859fc30dc7809864ca115f79b556ee4607f.tar.gz
org.eclipse.papyrus-337bb859fc30dc7809864ca115f79b556ee4607f.tar.xz
org.eclipse.papyrus-337bb859fc30dc7809864ca115f79b556ee4607f.zip
Version 0.9 of the alf editor, compatible with Papyrus 0.8
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/.classpath8
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/.project28
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/.settings/net.sf.jautodoc.prefs7
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/.settings/org.eclipse.jdt.core.prefs12
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/META-INF/MANIFEST.MF22
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/build.properties5
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/build.xml89
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/plugin.xml184
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/plugin.xml_gen183
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/AbstractAlfUiModule.java97
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/AlfExecutableExtensionFactory.java27
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/AbstractAlfProposalProvider.java908
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/AlfParser.java433
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g19052
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.tokens212
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlfLexer.java4658
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlfParser.java53155
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/internal/AlfActivator.java82
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/AlfUiModule.java25
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/contentassist/AlfProposalProvider.java180
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/labeling/AlfDescriptionLabelProvider.java37
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/labeling/AlfLabelProvider.java44
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/outline/AlfOutlineTreeProvider.java14
-rw-r--r--extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/quickfix/AlfQuickfixProvider.java32
24 files changed, 79494 insertions, 0 deletions
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.classpath b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.classpath
new file mode 100644
index 00000000000..ed2585fb3f4
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
+ <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="src" path="src-gen"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.project b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.project
new file mode 100644
index 00000000000..4cf1acb6870
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>org.eclipse.papyrus.alf.ui</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.pde.ManifestBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.pde.SchemaBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ <nature>org.eclipse.pde.PluginNature</nature>
+ </natures>
+</projectDescription>
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.settings/net.sf.jautodoc.prefs b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.settings/net.sf.jautodoc.prefs
new file mode 100644
index 00000000000..04da9c0ce04
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.settings/net.sf.jautodoc.prefs
@@ -0,0 +1,7 @@
+#Fri Jul 22 09:12:38 CEST 2011
+add_header=true
+eclipse.preferences.version=1
+header_text=/*****************************************************************************\r\n * Copyright (c) 2011 CEA LIST.\r\n *\r\n * \r\n * All rights reserved. This program and the accompanying materials\r\n * are made available under the terms of the Eclipse Public License v1.0\r\n * which accompanies this distribution, and is available at\r\n * http\://www.eclipse.org/legal/epl-v10.html\r\n *\r\n * Contributors\:\r\n * CEA LIST - Initial API and implementation\r\n *\r\n *****************************************************************************/
+project_specific_settings=true
+replace_header=true
+replacements=<?xml version\="1.0" standalone\="yes"?>\n\n<replacements>\n<replacement key\="get" scope\="1" mode\="0">Gets the</replacement>\n<replacement key\="set" scope\="1" mode\="0">Sets the</replacement>\n<replacement key\="add" scope\="1" mode\="0">Adds the</replacement>\n<replacement key\="edit" scope\="1" mode\="0">Edits the</replacement>\n<replacement key\="remove" scope\="1" mode\="0">Removes the</replacement>\n<replacement key\="init" scope\="1" mode\="0">Inits the</replacement>\n<replacement key\="parse" scope\="1" mode\="0">Parses the</replacement>\n<replacement key\="create" scope\="1" mode\="0">Creates the</replacement>\n<replacement key\="build" scope\="1" mode\="0">Builds the</replacement>\n<replacement key\="is" scope\="1" mode\="0">Checks if is</replacement>\n<replacement key\="print" scope\="1" mode\="0">Prints the</replacement>\n<replacement key\="has" scope\="1" mode\="0">Checks for</replacement>\n</replacements>\n\n
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.settings/org.eclipse.jdt.core.prefs b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 00000000000..47447961c5c
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,12 @@
+#Tue Apr 26 18:50:13 CEST 2011
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.5
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/META-INF/MANIFEST.MF b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/META-INF/MANIFEST.MF
new file mode 100644
index 00000000000..76872f852c1
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/META-INF/MANIFEST.MF
@@ -0,0 +1,22 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.papyrus.alf.ui
+Bundle-Vendor: Eclipse Modeling Project
+Bundle-Version: 0.9.0.qualifier
+Bundle-SymbolicName: org.eclipse.papyrus.alf.ui; singleton:=true
+Bundle-ActivationPolicy: lazy
+Require-Bundle: org.eclipse.papyrus.alf;visibility:=reexport,
+ org.eclipse.xtext.ui,
+ org.eclipse.ui.editors;bundle-version="3.5.0",
+ org.eclipse.ui.ide;bundle-version="3.5.0",
+ org.eclipse.xtext.ui.shared,
+ org.eclipse.ui,
+ org.eclipse.xtext.builder,
+ org.antlr.runtime,
+ org.eclipse.uml2.uml;bundle-version="3.2.0",
+ org.eclipse.xtext.gmf.glue;bundle-version="0.8.2"
+Import-Package: org.apache.log4j
+Bundle-RequiredExecutionEnvironment: J2SE-1.5
+Bundle-Activator: org.eclipse.papyrus.alf.ui.internal.AlfActivator
+Export-Package: org.eclipse.papyrus.alf.ui.contentassist,
+ org.eclipse.papyrus.alf.ui.contentassist.antlr
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/build.properties b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/build.properties
new file mode 100644
index 00000000000..e10dcceb6a3
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/build.properties
@@ -0,0 +1,5 @@
+source.. = src/,\
+ src-gen/
+bin.includes = META-INF/,\
+ .,\
+ plugin.xml \ No newline at end of file
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/build.xml b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/build.xml
new file mode 100644
index 00000000000..753cb8050ca
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/build.xml
@@ -0,0 +1,89 @@
+<project name="org.eclipse.papyrus.alf.ui" basedir=".">
+
+ <!-- Define the build directories-->
+ <property name="src.dir" value="${basedir}\src"/>
+ <property name="src.gen.dir" value="${basedir}\src-gen"/>
+ <property name="build.dir" value="${basedir}\bin"/>
+ <property name="build.infos.dir" value="${basedir}\buildinfos"/>
+
+ <!-- Define the location were javac can find required plugins -->
+ <property environment="env"/>
+ <path id="eclipse.classpath">
+ <fileset dir="${env.ECLIPSE_HOME}\plugins">
+ <include name="*.jar"/>
+ </fileset>
+ </path>
+
+ <!-- Define the location were lib used by pmd are stored -->
+ <path id="pmd.classpath">
+ <fileset dir="${env.PMD_HOME}\lib">
+ <include name="*.jar"/>
+ </fileset>
+ </path>
+
+ <!-- Define the location of the jar file containing the alf implementation-->
+ <path id="org.eclipse.papyrus.alf">
+ <fileset dir="..\..\org.eclipse.papyrus.alf\workspace\plugin">
+ <include name="org.eclipse.papyrus.alf.jar"/>
+ </fileset>
+ </path>
+
+ <!-- Define entry point when you find an element named findbugs -->
+ <taskdef name="findbugs" classpath="${env.FINDBUGS_HOME}\lib\findbugs-ant.jar" classname="edu.umd.cs.findbugs.anttask.FindBugsTask"/>
+
+ <!-- Define entry point when you find an element named PMD -->
+ <taskdef name="pmd" classpathref="pmd.classpath" classname="net.sourceforge.pmd.ant.PMDTask"/>
+
+ <!-- Set up directories for the build and info that have to be retrieved in hudson-->
+ <target name="init">
+ <tstamp/>
+ <delete dir="${build.dir}"/>
+ <mkdir dir="${build.dir}"/>
+ <delete dir="${build.infos.dir}"/>
+ <mkdir dir="${build.infos.dir}"/>
+ <mkdir dir="${build.infos.dir}\bugsreport"/>
+ <mkdir dir="${build.infos.dir}\checkstyle"/>
+ </target>
+
+ <!-- Perfom a checkstyle on the code with pmd tool. Compiling is not required -->
+ <target name="pmd" depends="init">
+ <pmd shortfilenames="true">
+ <ruleset>${env.PMD_HOME}\lib\rulesets\java\basic.xml</ruleset>
+ <ruleset>${env.PMD_HOME}\lib\rulesets\java\unusedcode.xml</ruleset>
+ <ruleset>${env.PMD_HOME}\lib\rulesets\java\unnecessary.xml</ruleset>
+ <ruleset>${env.PMD_HOME}\lib\rulesets\java\codesize.xml</ruleset>
+ <ruleset>${env.PMD_HOME}\lib\rulesets\java\strictexception.xml</ruleset>
+ <ruleset>${env.PMD_HOME}\lib\rulesets\java\braces.xml</ruleset>
+ <formatter type="xml" toFile="${build.infos.dir}\checkstyle\${ant.project.name}.pmd.xml"/>
+ <fileset dir="${src.dir}">
+ <include name="**/*.java"/>
+ </fileset>
+ <auxclasspath path="${src.gen.dir}"/>
+ </pmd>
+ </target>
+
+ <!-- Compilation phase of the project -->
+ <target name="compile" depends="pmd">
+ <echo message="${toString:org.eclipse.papyrus.alf}"/>
+ <javac includeantruntime="false" srcdir="${src.dir}" destdir="${build.dir}">
+ <compilerarg value="-Xlint:all"/>
+ <classpath refid="org.eclipse.papyrus.alf"/>
+ <classpath refid="eclipse.classpath"/>
+ </javac>
+ <javac includeantruntime="false" srcdir="${src.gen.dir}" destdir="${build.dir}">
+ <compilerarg value="-Xlint:all"/>
+ <classpath refid="org.eclipse.papyrus.alf"/>
+ <classpath refid="eclipse.classpath"/>
+ </javac>
+ </target>
+
+ <!-- Try to detect bugs within code after compiling -->
+ <target name="findbugs" depends="compile">
+ <findbugs home="${env.FINDBUGS_HOME}" output="xml" outputfile="${build.infos.dir}\bugsreport\${ant.project.name}.sa.xml">
+ <class location="${build.dir}"/>
+ <auxclasspath refid="eclipse.classpath"/>
+ <auxclasspath path="${src.gen.dir}"/>
+ <sourcePath path="${src.dir}"/>
+ </findbugs>
+ </target>
+</project> \ No newline at end of file
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/plugin.xml b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/plugin.xml
new file mode 100644
index 00000000000..b0d8a26d0bd
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/plugin.xml
@@ -0,0 +1,184 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+
+<plugin>
+
+ <extension
+ point="org.eclipse.ui.editors">
+ <editor
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.XtextEditor"
+ contributorClass="org.eclipse.ui.editors.text.TextEditorActionContributor"
+ default="true"
+ extensions="alf"
+ id="org.eclipse.papyrus.alf.Alf"
+ name="Alf Editor">
+ </editor>
+ </extension>
+ <extension
+ point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclarationHandler"
+ commandId="org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclaration">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ <handler
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.handler.ValidateActionHandler"
+ commandId="org.eclipse.papyrus.alf.Alf.validate">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+ <extension point="org.eclipse.core.expressions.definitions">
+ <definition id="org.eclipse.papyrus.alf.Alf.Editor.opened">
+ <and>
+ <reference definitionId="isActiveEditorAnInstanceOfXtextEditor"/>
+ <with variable="activeEditor">
+ <test property="org.eclipse.xtext.ui.editor.XtextEditor.languageName"
+ value="org.eclipse.papyrus.alf.Alf"
+ forcePluginActivation="true"/>
+ </with>
+ </and>
+ </definition>
+ </extension>
+ <extension
+ point="org.eclipse.ui.preferencePages">
+ <page
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.preferences.LanguageRootPreferencePage"
+ id="org.eclipse.papyrus.alf.Alf"
+ name="Alf">
+ <keywordReference id="org.eclipse.papyrus.alf.ui.keyword_Alf"/>
+ </page>
+ <page
+ category="org.eclipse.papyrus.alf.Alf"
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.syntaxcoloring.SyntaxColoringPreferencePage"
+ id="org.eclipse.papyrus.alf.Alf.coloring"
+ name="Syntax Coloring">
+ <keywordReference id="org.eclipse.papyrus.alf.ui.keyword_Alf"/>
+ </page>
+ <page
+ category="org.eclipse.papyrus.alf.Alf"
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.templates.XtextTemplatePreferencePage"
+ id="org.eclipse.papyrus.alf.Alf.templates"
+ name="Templates">
+ <keywordReference id="org.eclipse.papyrus.alf.ui.keyword_Alf"/>
+ </page>
+ </extension>
+ <extension
+ point="org.eclipse.ui.keywords">
+ <keyword
+ id="org.eclipse.papyrus.alf.ui.keyword_Alf"
+ label="Alf"/>
+ </extension>
+ <extension
+ point="org.eclipse.ui.commands">
+ <command
+ description="Trigger expensive validation"
+ id="org.eclipse.papyrus.alf.Alf.validate"
+ name="Validate">
+ </command>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution
+ locationURI="popup:#TextEditorContext?after=group.edit">
+ <command
+ commandId="org.eclipse.papyrus.alf.Alf.validate"
+ style="push"
+ tooltip="Trigger expensive validation">
+ <visibleWhen checkEnabled="false">
+ <reference
+ definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+ </reference>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution locationURI="popup:#TextEditorContext?endof=group.find">
+ <command commandId="org.eclipse.xtext.ui.editor.FindReferences">
+ <visibleWhen checkEnabled="false">
+ <reference definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+ </reference>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <extension point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.findrefs.FindReferencesHandler"
+ commandId="org.eclipse.xtext.ui.editor.FindReferences">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+
+<!-- adding resource factories -->
+
+ <extension
+ point="org.eclipse.emf.ecore.extension_parser">
+ <parser
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.resource.IResourceFactory"
+ type="alf">
+ </parser>
+ </extension>
+ <extension point="org.eclipse.xtext.extension_resourceServiceProvider">
+ <resourceServiceProvider
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.resource.IResourceUIServiceProvider"
+ uriExtension="alf">
+ </resourceServiceProvider>
+ </extension>
+
+
+
+
+ <!-- Quick Outline -->
+ <extension
+ point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.outline.quickoutline.ShowQuickOutlineActionHandler"
+ commandId="org.eclipse.xtext.ui.editor.outline.QuickOutline">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+ <extension
+ point="org.eclipse.ui.commands">
+ <command
+ description="Open the quick outline."
+ id="org.eclipse.xtext.ui.editor.outline.QuickOutline"
+ name="Quick Outline">
+ </command>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution
+ locationURI="popup:#TextEditorContext?after=group.open">
+ <command commandId="org.eclipse.xtext.ui.editor.outline.QuickOutline"
+ style="push"
+ tooltip="Open Quick Outline">
+ <visibleWhen checkEnabled="false">
+ <reference definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened"/>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <!-- quickfix marker resolution generator -->
+ <extension
+ point="org.eclipse.ui.ide.markerResolution">
+ <markerResolutionGenerator
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator">
+ </markerResolutionGenerator>
+ </extension>
+
+</plugin>
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/plugin.xml_gen b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/plugin.xml_gen
new file mode 100644
index 00000000000..938feb4acd5
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/plugin.xml_gen
@@ -0,0 +1,183 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+
+<plugin>
+
+ <extension
+ point="org.eclipse.ui.editors">
+ <editor
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.XtextEditor"
+ contributorClass="org.eclipse.ui.editors.text.TextEditorActionContributor"
+ default="true"
+ extensions="alf"
+ id="org.eclipse.papyrus.alf.Alf"
+ name="Alf Editor">
+ </editor>
+ </extension>
+ <extension
+ point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclarationHandler"
+ commandId="org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclaration">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ <handler
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.handler.ValidateActionHandler"
+ commandId="org.eclipse.papyrus.alf.Alf.validate">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+ <extension point="org.eclipse.core.expressions.definitions">
+ <definition id="org.eclipse.papyrus.alf.Alf.Editor.opened">
+ <and>
+ <reference definitionId="isActiveEditorAnInstanceOfXtextEditor"/>
+ <with variable="activeEditor">
+ <test property="org.eclipse.xtext.ui.editor.XtextEditor.languageName"
+ value="org.eclipse.papyrus.alf.Alf"
+ forcePluginActivation="true"/>
+ </with>
+ </and>
+ </definition>
+ </extension>
+ <extension
+ point="org.eclipse.ui.preferencePages">
+ <page
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.preferences.LanguageRootPreferencePage"
+ id="org.eclipse.papyrus.alf.Alf"
+ name="Alf">
+ <keywordReference id="org.eclipse.papyrus.alf.ui.keyword_Alf"/>
+ </page>
+ <page
+ category="org.eclipse.papyrus.alf.Alf"
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.syntaxcoloring.SyntaxColoringPreferencePage"
+ id="org.eclipse.papyrus.alf.Alf.coloring"
+ name="Syntax Coloring">
+ <keywordReference id="org.eclipse.papyrus.alf.ui.keyword_Alf"/>
+ </page>
+ <page
+ category="org.eclipse.papyrus.alf.Alf"
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.templates.XtextTemplatePreferencePage"
+ id="org.eclipse.papyrus.alf.Alf.templates"
+ name="Templates">
+ <keywordReference id="org.eclipse.papyrus.alf.ui.keyword_Alf"/>
+ </page>
+ </extension>
+ <extension
+ point="org.eclipse.ui.keywords">
+ <keyword
+ id="org.eclipse.papyrus.alf.ui.keyword_Alf"
+ label="Alf"/>
+ </extension>
+ <extension
+ point="org.eclipse.ui.commands">
+ <command
+ description="Trigger expensive validation"
+ id="org.eclipse.papyrus.alf.Alf.validate"
+ name="Validate">
+ </command>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution
+ locationURI="popup:#TextEditorContext?after=group.edit">
+ <command
+ commandId="org.eclipse.papyrus.alf.Alf.validate"
+ style="push"
+ tooltip="Trigger expensive validation">
+ <visibleWhen checkEnabled="false">
+ <reference
+ definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+ </reference>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution locationURI="popup:#TextEditorContext?endof=group.find">
+ <command commandId="org.eclipse.xtext.ui.editor.FindReferences">
+ <visibleWhen checkEnabled="false">
+ <reference definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+ </reference>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <extension point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.findrefs.FindReferencesHandler"
+ commandId="org.eclipse.xtext.ui.editor.FindReferences">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+
+<!-- adding resource factories -->
+
+ <extension
+ point="org.eclipse.emf.ecore.extension_parser">
+ <parser
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.resource.IResourceFactory"
+ type="alf">
+ </parser>
+ </extension>
+ <extension point="org.eclipse.xtext.extension_resourceServiceProvider">
+ <resourceServiceProvider
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.resource.IResourceUIServiceProvider"
+ uriExtension="alf">
+ </resourceServiceProvider>
+ </extension>
+
+
+
+ <!-- Quick Outline -->
+ <extension
+ point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.outline.quickoutline.ShowQuickOutlineActionHandler"
+ commandId="org.eclipse.xtext.ui.editor.outline.QuickOutline">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+ <extension
+ point="org.eclipse.ui.commands">
+ <command
+ description="Open the quick outline."
+ id="org.eclipse.xtext.ui.editor.outline.QuickOutline"
+ name="Quick Outline">
+ </command>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution
+ locationURI="popup:#TextEditorContext?after=group.open">
+ <command commandId="org.eclipse.xtext.ui.editor.outline.QuickOutline"
+ style="push"
+ tooltip="Open Quick Outline">
+ <visibleWhen checkEnabled="false">
+ <reference definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened"/>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <!-- quickfix marker resolution generator -->
+ <extension
+ point="org.eclipse.ui.ide.markerResolution">
+ <markerResolutionGenerator
+ class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator">
+ </markerResolutionGenerator>
+ </extension>
+
+</plugin>
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/AbstractAlfUiModule.java b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/AbstractAlfUiModule.java
new file mode 100644
index 00000000000..ee633226c1a
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/AbstractAlfUiModule.java
@@ -0,0 +1,97 @@
+
+/*
+ * generated by Xtext
+ */
+package org.eclipse.papyrus.alf.ui;
+
+import org.eclipse.xtext.ui.DefaultUiModule;
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+
+/**
+ * Manual modifications go to {org.eclipse.papyrus.alf.ui.AlfUiModule}
+ */
+@SuppressWarnings("all")
+public abstract class AbstractAlfUiModule extends DefaultUiModule {
+
+ public AbstractAlfUiModule(AbstractUIPlugin plugin) {
+ super(plugin);
+ }
+
+
+ // contributed by org.eclipse.xtext.ui.generator.ImplicitUiFragment
+ public com.google.inject.Provider<org.eclipse.xtext.resource.containers.IAllContainersState> provideIAllContainersState() {
+ return org.eclipse.xtext.ui.shared.Access.getJavaProjectsState();
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment
+ public Class<? extends org.eclipse.xtext.ui.editor.contentassist.IProposalConflictHelper> bindIProposalConflictHelper() {
+ return org.eclipse.xtext.ui.editor.contentassist.antlr.AntlrProposalConflictHelper.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment
+ public void configureHighlightingLexer(com.google.inject.Binder binder) {
+ binder.bind(org.eclipse.xtext.parser.antlr.Lexer.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.ui.LexerUIBindings.HIGHLIGHTING)).to(org.eclipse.papyrus.alf.parser.antlr.internal.InternalAlfLexer.class);
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment
+ public void configureHighlightingTokenDefProvider(com.google.inject.Binder binder) {
+ binder.bind(org.eclipse.xtext.parser.antlr.ITokenDefProvider.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.ui.LexerUIBindings.HIGHLIGHTING)).to(org.eclipse.xtext.parser.antlr.AntlrTokenDefProvider.class);
+ }
+
+ // contributed by org.eclipse.xtext.generator.exporting.SimpleNamesFragment
+ public Class<? extends org.eclipse.xtext.ui.refactoring.IDependentElementsCalculator> bindIDependentElementsCalculator() {
+ return org.eclipse.xtext.ui.refactoring.IDependentElementsCalculator.Null.class;
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.labeling.LabelProviderFragment
+ public Class<? extends org.eclipse.jface.viewers.ILabelProvider> bindILabelProvider() {
+ return org.eclipse.papyrus.alf.ui.labeling.AlfLabelProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.labeling.LabelProviderFragment
+ public void configureResourceUIServiceLabelProvider(com.google.inject.Binder binder) {
+ binder.bind(org.eclipse.jface.viewers.ILabelProvider.class).annotatedWith(org.eclipse.xtext.ui.resource.ResourceServiceDescriptionLabelProvider.class).to(org.eclipse.papyrus.alf.ui.labeling.AlfDescriptionLabelProvider.class);
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.outline.OutlineTreeProviderFragment
+ public Class<? extends org.eclipse.xtext.ui.editor.outline.IOutlineTreeProvider> bindIOutlineTreeProvider() {
+ return org.eclipse.papyrus.alf.ui.outline.AlfOutlineTreeProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.outline.OutlineTreeProviderFragment
+ public Class<? extends org.eclipse.xtext.ui.editor.outline.impl.IOutlineTreeStructureProvider> bindIOutlineTreeStructureProvider() {
+ return org.eclipse.papyrus.alf.ui.outline.AlfOutlineTreeProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.quickfix.QuickfixProviderFragment
+ public Class<? extends org.eclipse.xtext.ui.editor.quickfix.IssueResolutionProvider> bindIssueResolutionProvider() {
+ return org.eclipse.papyrus.alf.ui.quickfix.AlfQuickfixProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.contentAssist.JavaBasedContentAssistFragment
+ public Class<? extends org.eclipse.xtext.ui.editor.contentassist.IContentProposalProvider> bindIContentProposalProvider() {
+ return org.eclipse.papyrus.alf.ui.contentassist.AlfProposalProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment
+ public Class<? extends org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext.Factory> bindContentAssistContext$Factory() {
+ return org.eclipse.xtext.ui.editor.contentassist.antlr.ParserBasedContentAssistContextFactory.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment
+ public Class<? extends org.eclipse.xtext.ui.editor.contentassist.antlr.IContentAssistParser> bindIContentAssistParser() {
+ return org.eclipse.papyrus.alf.ui.contentassist.antlr.AlfParser.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment
+ public void configureContentAssistLexerProvider(com.google.inject.Binder binder) {
+ binder.bind(org.eclipse.papyrus.alf.ui.contentassist.antlr.internal.InternalAlfLexer.class).toProvider(org.eclipse.xtext.parser.antlr.LexerProvider.create(org.eclipse.papyrus.alf.ui.contentassist.antlr.internal.InternalAlfLexer.class));
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment
+ public void configureContentAssistLexer(com.google.inject.Binder binder) {
+ binder.bind(org.eclipse.xtext.ui.editor.contentassist.antlr.internal.Lexer.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.ui.LexerUIBindings.CONTENT_ASSIST)).to(org.eclipse.papyrus.alf.ui.contentassist.antlr.internal.InternalAlfLexer.class);
+ }
+
+
+}
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/AlfExecutableExtensionFactory.java b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/AlfExecutableExtensionFactory.java
new file mode 100644
index 00000000000..5cf50829ae8
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/AlfExecutableExtensionFactory.java
@@ -0,0 +1,27 @@
+/*
+ * generated by Xtext
+ */
+package org.eclipse.papyrus.alf.ui;
+
+import org.eclipse.xtext.ui.guice.AbstractGuiceAwareExecutableExtensionFactory;
+import org.osgi.framework.Bundle;
+
+import com.google.inject.Injector;
+
+/**
+ * This class was generated. Customizations should only happen in a newly
+ * introduced subclass.
+ */
+public class AlfExecutableExtensionFactory extends AbstractGuiceAwareExecutableExtensionFactory {
+
+ @Override
+ protected Bundle getBundle() {
+ return org.eclipse.papyrus.alf.ui.internal.AlfActivator.getInstance().getBundle();
+ }
+
+ @Override
+ protected Injector getInjector() {
+ return org.eclipse.papyrus.alf.ui.internal.AlfActivator.getInstance().getInjector("org.eclipse.papyrus.alf.Alf");
+ }
+
+}
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/AbstractAlfProposalProvider.java b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/AbstractAlfProposalProvider.java
new file mode 100644
index 00000000000..9f5a992db81
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/AbstractAlfProposalProvider.java
@@ -0,0 +1,908 @@
+/*
+* generated by Xtext
+*/
+package org.eclipse.papyrus.alf.ui.contentassist;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.common.ui.contentassist.TerminalsProposalProvider;
+import org.eclipse.xtext.ui.editor.contentassist.ICompletionProposalAcceptor;
+import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext;
+
+/**
+ * Represents a generated, default implementation of interface {@link IProposalProvider}.
+ * Methods are dynamically dispatched on the first parameter, i.e., you can override them
+ * with a more concrete subtype.
+ */
+@SuppressWarnings("all")
+public class AbstractAlfProposalProvider extends TerminalsProposalProvider {
+
+ public void completeTest_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeTest_AssignExpression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeTest_Statements(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeTest_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeBOOLEAN_LITERAL_Value(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeINTEGER_LITERAL_Value(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeUNLIMITED_LITERAL_Value(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void completeSTRING_LITERAL_Value(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeNameExpression_PrefixOp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ // subclasses may override
+ }
+ public void completeNameExpression_Path(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeNameExpression_Id(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeNameExpression_InvocationCompletion(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeNameExpression_SequenceConstructionCompletion(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeNameExpression_PostfixOp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ // subclasses may override
+ }
+ public void completeNameExpression_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeQualifiedNamePath_Namespace(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeUnqualifiedName_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeUnqualifiedName_TemplateBinding(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeTemplateBinding_Bindings(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeNamedTemplateBinding_Formal(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeNamedTemplateBinding_Actual(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeQualifiedNameWithBinding_Id(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeQualifiedNameWithBinding_Binding(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeQualifiedNameWithBinding_Remaining(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeTuple_TupleElements(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeTupleElement_Argument(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeConditionalTestExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeConditionalTestExpression_WhenTrue(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeConditionalTestExpression_WhenFalse(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeConditionalOrExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeConditionalAndExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeInclusiveOrExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeExclusiveOrExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeAndExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeEqualityExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeEqualityExpression_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ // subclasses may override
+ }
+ public void completeClassificationExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeClassificationExpression_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ // subclasses may override
+ }
+ public void completeClassificationExpression_TypeName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeRelationalExpression_Left(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeRelationalExpression_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ // subclasses may override
+ // subclasses may override
+ // subclasses may override
+ }
+ public void completeRelationalExpression_Right(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeShiftExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeShiftExpression_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ // subclasses may override
+ // subclasses may override
+ }
+ public void completeAdditiveExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeAdditiveExpression_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ // subclasses may override
+ }
+ public void completeMultiplicativeExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeMultiplicativeExpression_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ // subclasses may override
+ // subclasses may override
+ }
+ public void completeUnaryExpression_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ // subclasses may override
+ // subclasses may override
+ // subclasses may override
+ // subclasses may override
+ }
+ public void completeUnaryExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completePrimaryExpression_Prefix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeOperationCallExpression_OperationName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeOperationCallExpression_Tuple(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeOperationCallExpression_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completePropertyCallExpression_PropertyName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completePropertyCallExpression_Index(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completePropertyCallExpression_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeLinkOperationExpression_Kind(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeLinkOperationExpression_Tuple(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeLinkOperationTuple_LinkOperationTupleElement(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeLinkOperationTupleElement_Role(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeLinkOperationTupleElement_RoleIndex(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeLinkOperationTupleElement_Object(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSequenceOperationExpression_OperationName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSequenceOperationExpression_Tuple(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSequenceOperationExpression_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSequenceReductionExpression_IsOrdered(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void completeSequenceReductionExpression_Behavior(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSequenceReductionExpression_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSelectOrRejectOperation_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSelectOrRejectOperation_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSelectOrRejectOperation_Expr(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSelectOrRejectOperation_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeCollectOrIterateOperation_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeCollectOrIterateOperation_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeCollectOrIterateOperation_Expr(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeCollectOrIterateOperation_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeForAllOrExistsOrOneOperation_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeForAllOrExistsOrOneOperation_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeForAllOrExistsOrOneOperation_Expr(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeForAllOrExistsOrOneOperation_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeIsUniqueOperation_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeIsUniqueOperation_Expr(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeIsUniqueOperation_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeParenthesizedExpression_ExpOrTypeCast(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeParenthesizedExpression_Casted(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeParenthesizedExpression_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeThisExpression_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSuperInvocationExpression_Tuple(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSuperInvocationExpression_OperationName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeInstanceCreationExpression_Constructor(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeInstanceCreationExpression_Tuple(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeInstanceCreationExpression_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeInstanceCreationTuple_InstanceCreationTupleElement(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeInstanceCreationTupleElement_Role(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeInstanceCreationTupleElement_Object(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSequenceConstructionOrAccessCompletion_MultiplicityIndicator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void completeSequenceConstructionOrAccessCompletion_AccessCompletion(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSequenceConstructionOrAccessCompletion_SequenceCompletion(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSequenceConstructionOrAccessCompletion_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeAccessCompletion_AccessIndex(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completePartialSequenceConstructionCompletion_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSequenceConstructionExpression_SequenceElement(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSequenceConstructionExpression_RangeUpper(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeBlock_Sequence(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeStatementSequence_Statements(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeDocumentedStatement_Comment(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)((Alternatives)assignment.getTerminal()).getElements().get(0)), context, acceptor);
+ completeRuleCall(((RuleCall)((Alternatives)assignment.getTerminal()).getElements().get(1)), context, acceptor);
+ }
+ public void completeDocumentedStatement_Statement(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeInlineStatement_LangageName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeInlineStatement_Body(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeAnnotatedStatement_Annotation(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeAnnotatedStatement_Statement(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeAnnotation_Kind(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeAnnotation_Args(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeBlockStatement_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeLocalNameDeclarationStatement_VarName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeLocalNameDeclarationStatement_Type(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeLocalNameDeclarationStatement_MultiplicityIndicator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void completeLocalNameDeclarationStatement_Init(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeIfStatement_SequentialClausses(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeIfStatement_FinalClause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSequentialClauses_ConccurentClauses(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeConcurrentClauses_NonFinalClause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeNonFinalClause_Condition(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeNonFinalClause_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeFinalClause_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSwitchStatement_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSwitchStatement_SwitchClause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSwitchStatement_DefaultClause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSwitchClause_SwitchCase(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSwitchClause_StatementSequence(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSwitchCase_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSwitchDefaultClause_StatementSequence(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeNonEmptyStatementSequence_Statement(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeWhileStatement_Condition(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeWhileStatement_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeDoStatement_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeDoStatement_Condition(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeForStatement_Control(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeForStatement_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeForControl_LoopVariableDefinition(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeLoopVariableDefinition_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeLoopVariableDefinition_Expression1(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeLoopVariableDefinition_Expression2(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeLoopVariableDefinition_Type(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeLoopVariableDefinition_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeReturnStatement_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeAcceptStatement_Clause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeAcceptStatement_SimpleAccept(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeAcceptStatement_CompoundAccept(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeCompoundAcceptStatementCompletion_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeCompoundAcceptStatementCompletion_AcceptBlock(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeAcceptBlock_Clause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeAcceptBlock_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeAcceptClause_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeAcceptClause_QualifiedNameList(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeClassifyStatement_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeClassifyStatement_Clause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeClassificationClause_ClassifyFromClause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeClassificationClause_ClassifyToClause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeClassificationClause_ReclassyAllClause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeClassificationFromClause_QualifiedNameList(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeClassificationToClause_QualifiedNameList(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeQualifiedNameList_QualifiedName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeInvocationOrAssignementOrDeclarationStatement_TypePart_OR_assignedPart_OR_invocationPart(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeInvocationOrAssignementOrDeclarationStatement_VariableDeclarationCompletion(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeInvocationOrAssignementOrDeclarationStatement_AssignmentCompletion(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeSuperInvocationStatement__super(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeThisInvocationStatement__this(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeThisInvocationStatement_AssignmentCompletion(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeInstanceCreationInvocationStatement__new(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeVariableDeclarationCompletion_MultiplicityIndicator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void completeVariableDeclarationCompletion_VariableName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeVariableDeclarationCompletion_InitValue(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeAssignmentCompletion_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeAssignmentCompletion_RightHandSide(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+
+ public void complete_Test(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_LITERAL(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_BOOLEAN_LITERAL(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_BooleanValue(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_NUMBER_LITERAL(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_INTEGER_LITERAL(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_UNLIMITED_LITERAL(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_IntegerValue(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_STRING_LITERAL(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_NameExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_QualifiedNamePath(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_UnqualifiedName(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_TemplateBinding(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_NamedTemplateBinding(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_QualifiedNameWithBinding(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_Tuple(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_TupleElement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_Expression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ConditionalTestExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ConditionalOrExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ConditionalAndExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_InclusiveOrExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ExclusiveOrExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_AndExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_EqualityExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ClassificationExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_RelationalExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ShiftExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_AdditiveExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_MultiplicativeExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_UnaryExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_PrimaryExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SuffixExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_OperationCallExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_PropertyCallExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_LinkOperationExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_LinkOperationTuple(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_LinkOperationTupleElement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_LinkOperationKind(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SequenceOperationExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SequenceReductionExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SequenceExpansionExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SelectOrRejectOperation(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SelectOrRejectOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_CollectOrIterateOperation(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_CollectOrIterateOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ForAllOrExistsOrOneOperation(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ForAllOrExistsOrOneOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_IsUniqueOperation(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ValueSpecification(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_NonLiteralValueSpecification(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ParenthesizedExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_NullExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ThisExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SuperInvocationExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_InstanceCreationExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_InstanceCreationTuple(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_InstanceCreationTupleElement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SequenceConstructionOrAccessCompletion(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_AccessCompletion(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_PartialSequenceConstructionCompletion(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SequenceConstructionExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SequenceElement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ClassExtentExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_Block(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_StatementSequence(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_DocumentedStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_InlineStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_AnnotatedStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_Statement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_Annotation(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_AnnotationKind(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_BlockStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_EmptyStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_LocalNameDeclarationStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_IfStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SequentialClauses(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ConcurrentClauses(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_NonFinalClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_FinalClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SwitchStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SwitchClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SwitchCase(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SwitchDefaultClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_NonEmptyStatementSequence(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_WhileStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_DoStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ForStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ForControl(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_LoopVariableDefinition(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_BreakStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ReturnStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_AcceptStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SimpleAcceptStatementCompletion(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_CompoundAcceptStatementCompletion(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_AcceptBlock(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_AcceptClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ClassifyStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ClassificationClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ClassificationFromClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ClassificationToClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ReclassifyAllClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_QualifiedNameList(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_InvocationOrAssignementOrDeclarationStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SuperInvocationStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ThisInvocationStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_InstanceCreationInvocationStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_VariableDeclarationCompletion(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_AssignmentCompletion(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_AssignmentOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ID(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_STRING(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_ML_COMMENT(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_SL_COMMENT(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+}
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/AlfParser.java b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/AlfParser.java
new file mode 100644
index 00000000000..690f751643c
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/AlfParser.java
@@ -0,0 +1,433 @@
+/*
+* generated by Xtext
+*/
+package org.eclipse.papyrus.alf.ui.contentassist.antlr;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.HashMap;
+
+import org.antlr.runtime.RecognitionException;
+import org.eclipse.xtext.AbstractElement;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.AbstractContentAssistParser;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.FollowElement;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
+
+import com.google.inject.Inject;
+
+import org.eclipse.papyrus.alf.services.AlfGrammarAccess;
+
+public class AlfParser extends AbstractContentAssistParser {
+
+ @Inject
+ private AlfGrammarAccess grammarAccess;
+
+ private Map<AbstractElement, String> nameMappings;
+
+ @Override
+ protected org.eclipse.papyrus.alf.ui.contentassist.antlr.internal.InternalAlfParser createParser() {
+ org.eclipse.papyrus.alf.ui.contentassist.antlr.internal.InternalAlfParser result = new org.eclipse.papyrus.alf.ui.contentassist.antlr.internal.InternalAlfParser(null);
+ result.setGrammarAccess(grammarAccess);
+ return result;
+ }
+
+ @Override
+ protected String getRuleName(AbstractElement element) {
+ if (nameMappings == null) {
+ nameMappings = new HashMap<AbstractElement, String>() {
+ private static final long serialVersionUID = 1L;
+ {
+ put(grammarAccess.getLITERALAccess().getAlternatives(), "rule__LITERAL__Alternatives");
+ put(grammarAccess.getNUMBER_LITERALAccess().getAlternatives(), "rule__NUMBER_LITERAL__Alternatives");
+ put(grammarAccess.getNameExpressionAccess().getAlternatives_0(), "rule__NameExpression__Alternatives_0");
+ put(grammarAccess.getNameExpressionAccess().getPrefixOpAlternatives_0_0_0_0(), "rule__NameExpression__PrefixOpAlternatives_0_0_0_0");
+ put(grammarAccess.getNameExpressionAccess().getAlternatives_0_1_2(), "rule__NameExpression__Alternatives_0_1_2");
+ put(grammarAccess.getNameExpressionAccess().getPostfixOpAlternatives_0_1_2_2_0(), "rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0");
+ put(grammarAccess.getEqualityExpressionAccess().getOpAlternatives_1_0_0(), "rule__EqualityExpression__OpAlternatives_1_0_0");
+ put(grammarAccess.getClassificationExpressionAccess().getOpAlternatives_1_0_0(), "rule__ClassificationExpression__OpAlternatives_1_0_0");
+ put(grammarAccess.getRelationalExpressionAccess().getOpAlternatives_1_0_0(), "rule__RelationalExpression__OpAlternatives_1_0_0");
+ put(grammarAccess.getShiftExpressionAccess().getOpAlternatives_1_0_0(), "rule__ShiftExpression__OpAlternatives_1_0_0");
+ put(grammarAccess.getAdditiveExpressionAccess().getOpAlternatives_1_0_0(), "rule__AdditiveExpression__OpAlternatives_1_0_0");
+ put(grammarAccess.getMultiplicativeExpressionAccess().getOpAlternatives_1_0_0(), "rule__MultiplicativeExpression__OpAlternatives_1_0_0");
+ put(grammarAccess.getUnaryExpressionAccess().getOpAlternatives_0_0(), "rule__UnaryExpression__OpAlternatives_0_0");
+ put(grammarAccess.getSuffixExpressionAccess().getAlternatives(), "rule__SuffixExpression__Alternatives");
+ put(grammarAccess.getSequenceExpansionExpressionAccess().getAlternatives(), "rule__SequenceExpansionExpression__Alternatives");
+ put(grammarAccess.getValueSpecificationAccess().getAlternatives(), "rule__ValueSpecification__Alternatives");
+ put(grammarAccess.getNonLiteralValueSpecificationAccess().getAlternatives(), "rule__NonLiteralValueSpecification__Alternatives");
+ put(grammarAccess.getParenthesizedExpressionAccess().getAlternatives_3(), "rule__ParenthesizedExpression__Alternatives_3");
+ put(grammarAccess.getSuperInvocationExpressionAccess().getAlternatives_1(), "rule__SuperInvocationExpression__Alternatives_1");
+ put(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAlternatives(), "rule__SequenceConstructionOrAccessCompletion__Alternatives");
+ put(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAlternatives_0_1(), "rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1");
+ put(grammarAccess.getSequenceConstructionExpressionAccess().getAlternatives_2(), "rule__SequenceConstructionExpression__Alternatives_2");
+ put(grammarAccess.getSequenceElementAccess().getAlternatives(), "rule__SequenceElement__Alternatives");
+ put(grammarAccess.getDocumentedStatementAccess().getCommentAlternatives_0_0(), "rule__DocumentedStatement__CommentAlternatives_0_0");
+ put(grammarAccess.getStatementAccess().getAlternatives(), "rule__Statement__Alternatives");
+ put(grammarAccess.getLoopVariableDefinitionAccess().getAlternatives(), "rule__LoopVariableDefinition__Alternatives");
+ put(grammarAccess.getAcceptStatementAccess().getAlternatives_1(), "rule__AcceptStatement__Alternatives_1");
+ put(grammarAccess.getClassificationClauseAccess().getAlternatives(), "rule__ClassificationClause__Alternatives");
+ put(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAlternatives_1(), "rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1");
+ put(grammarAccess.getBooleanValueAccess().getAlternatives(), "rule__BooleanValue__Alternatives");
+ put(grammarAccess.getLinkOperationKindAccess().getAlternatives(), "rule__LinkOperationKind__Alternatives");
+ put(grammarAccess.getSelectOrRejectOperatorAccess().getAlternatives(), "rule__SelectOrRejectOperator__Alternatives");
+ put(grammarAccess.getCollectOrIterateOperatorAccess().getAlternatives(), "rule__CollectOrIterateOperator__Alternatives");
+ put(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getAlternatives(), "rule__ForAllOrExistsOrOneOperator__Alternatives");
+ put(grammarAccess.getAnnotationKindAccess().getAlternatives(), "rule__AnnotationKind__Alternatives");
+ put(grammarAccess.getAssignmentOperatorAccess().getAlternatives(), "rule__AssignmentOperator__Alternatives");
+ put(grammarAccess.getTestAccess().getGroup(), "rule__Test__Group__0");
+ put(grammarAccess.getTestAccess().getGroup_0(), "rule__Test__Group_0__0");
+ put(grammarAccess.getTestAccess().getGroup_1(), "rule__Test__Group_1__0");
+ put(grammarAccess.getTestAccess().getGroup_2(), "rule__Test__Group_2__0");
+ put(grammarAccess.getTestAccess().getGroup_3(), "rule__Test__Group_3__0");
+ put(grammarAccess.getNameExpressionAccess().getGroup(), "rule__NameExpression__Group__0");
+ put(grammarAccess.getNameExpressionAccess().getGroup_0_0(), "rule__NameExpression__Group_0_0__0");
+ put(grammarAccess.getNameExpressionAccess().getGroup_0_1(), "rule__NameExpression__Group_0_1__0");
+ put(grammarAccess.getQualifiedNamePathAccess().getGroup(), "rule__QualifiedNamePath__Group__0");
+ put(grammarAccess.getUnqualifiedNameAccess().getGroup(), "rule__UnqualifiedName__Group__0");
+ put(grammarAccess.getTemplateBindingAccess().getGroup(), "rule__TemplateBinding__Group__0");
+ put(grammarAccess.getTemplateBindingAccess().getGroup_2(), "rule__TemplateBinding__Group_2__0");
+ put(grammarAccess.getNamedTemplateBindingAccess().getGroup(), "rule__NamedTemplateBinding__Group__0");
+ put(grammarAccess.getQualifiedNameWithBindingAccess().getGroup(), "rule__QualifiedNameWithBinding__Group__0");
+ put(grammarAccess.getQualifiedNameWithBindingAccess().getGroup_2(), "rule__QualifiedNameWithBinding__Group_2__0");
+ put(grammarAccess.getTupleAccess().getGroup(), "rule__Tuple__Group__0");
+ put(grammarAccess.getTupleAccess().getGroup_2(), "rule__Tuple__Group_2__0");
+ put(grammarAccess.getTupleAccess().getGroup_2_1(), "rule__Tuple__Group_2_1__0");
+ put(grammarAccess.getConditionalTestExpressionAccess().getGroup(), "rule__ConditionalTestExpression__Group__0");
+ put(grammarAccess.getConditionalTestExpressionAccess().getGroup_1(), "rule__ConditionalTestExpression__Group_1__0");
+ put(grammarAccess.getConditionalOrExpressionAccess().getGroup(), "rule__ConditionalOrExpression__Group__0");
+ put(grammarAccess.getConditionalOrExpressionAccess().getGroup_1(), "rule__ConditionalOrExpression__Group_1__0");
+ put(grammarAccess.getConditionalAndExpressionAccess().getGroup(), "rule__ConditionalAndExpression__Group__0");
+ put(grammarAccess.getConditionalAndExpressionAccess().getGroup_1(), "rule__ConditionalAndExpression__Group_1__0");
+ put(grammarAccess.getInclusiveOrExpressionAccess().getGroup(), "rule__InclusiveOrExpression__Group__0");
+ put(grammarAccess.getInclusiveOrExpressionAccess().getGroup_1(), "rule__InclusiveOrExpression__Group_1__0");
+ put(grammarAccess.getExclusiveOrExpressionAccess().getGroup(), "rule__ExclusiveOrExpression__Group__0");
+ put(grammarAccess.getExclusiveOrExpressionAccess().getGroup_1(), "rule__ExclusiveOrExpression__Group_1__0");
+ put(grammarAccess.getAndExpressionAccess().getGroup(), "rule__AndExpression__Group__0");
+ put(grammarAccess.getAndExpressionAccess().getGroup_1(), "rule__AndExpression__Group_1__0");
+ put(grammarAccess.getEqualityExpressionAccess().getGroup(), "rule__EqualityExpression__Group__0");
+ put(grammarAccess.getEqualityExpressionAccess().getGroup_1(), "rule__EqualityExpression__Group_1__0");
+ put(grammarAccess.getClassificationExpressionAccess().getGroup(), "rule__ClassificationExpression__Group__0");
+ put(grammarAccess.getClassificationExpressionAccess().getGroup_1(), "rule__ClassificationExpression__Group_1__0");
+ put(grammarAccess.getRelationalExpressionAccess().getGroup(), "rule__RelationalExpression__Group__0");
+ put(grammarAccess.getRelationalExpressionAccess().getGroup_1(), "rule__RelationalExpression__Group_1__0");
+ put(grammarAccess.getShiftExpressionAccess().getGroup(), "rule__ShiftExpression__Group__0");
+ put(grammarAccess.getShiftExpressionAccess().getGroup_1(), "rule__ShiftExpression__Group_1__0");
+ put(grammarAccess.getAdditiveExpressionAccess().getGroup(), "rule__AdditiveExpression__Group__0");
+ put(grammarAccess.getAdditiveExpressionAccess().getGroup_1(), "rule__AdditiveExpression__Group_1__0");
+ put(grammarAccess.getMultiplicativeExpressionAccess().getGroup(), "rule__MultiplicativeExpression__Group__0");
+ put(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1(), "rule__MultiplicativeExpression__Group_1__0");
+ put(grammarAccess.getUnaryExpressionAccess().getGroup(), "rule__UnaryExpression__Group__0");
+ put(grammarAccess.getOperationCallExpressionAccess().getGroup(), "rule__OperationCallExpression__Group__0");
+ put(grammarAccess.getPropertyCallExpressionAccess().getGroup(), "rule__PropertyCallExpression__Group__0");
+ put(grammarAccess.getPropertyCallExpressionAccess().getGroup_2(), "rule__PropertyCallExpression__Group_2__0");
+ put(grammarAccess.getLinkOperationExpressionAccess().getGroup(), "rule__LinkOperationExpression__Group__0");
+ put(grammarAccess.getLinkOperationTupleAccess().getGroup(), "rule__LinkOperationTuple__Group__0");
+ put(grammarAccess.getLinkOperationTupleAccess().getGroup_2(), "rule__LinkOperationTuple__Group_2__0");
+ put(grammarAccess.getLinkOperationTupleElementAccess().getGroup(), "rule__LinkOperationTupleElement__Group__0");
+ put(grammarAccess.getLinkOperationTupleElementAccess().getGroup_1(), "rule__LinkOperationTupleElement__Group_1__0");
+ put(grammarAccess.getSequenceOperationExpressionAccess().getGroup(), "rule__SequenceOperationExpression__Group__0");
+ put(grammarAccess.getSequenceReductionExpressionAccess().getGroup(), "rule__SequenceReductionExpression__Group__0");
+ put(grammarAccess.getSelectOrRejectOperationAccess().getGroup(), "rule__SelectOrRejectOperation__Group__0");
+ put(grammarAccess.getCollectOrIterateOperationAccess().getGroup(), "rule__CollectOrIterateOperation__Group__0");
+ put(grammarAccess.getForAllOrExistsOrOneOperationAccess().getGroup(), "rule__ForAllOrExistsOrOneOperation__Group__0");
+ put(grammarAccess.getIsUniqueOperationAccess().getGroup(), "rule__IsUniqueOperation__Group__0");
+ put(grammarAccess.getParenthesizedExpressionAccess().getGroup(), "rule__ParenthesizedExpression__Group__0");
+ put(grammarAccess.getNullExpressionAccess().getGroup(), "rule__NullExpression__Group__0");
+ put(grammarAccess.getThisExpressionAccess().getGroup(), "rule__ThisExpression__Group__0");
+ put(grammarAccess.getSuperInvocationExpressionAccess().getGroup(), "rule__SuperInvocationExpression__Group__0");
+ put(grammarAccess.getSuperInvocationExpressionAccess().getGroup_1_1(), "rule__SuperInvocationExpression__Group_1_1__0");
+ put(grammarAccess.getInstanceCreationExpressionAccess().getGroup(), "rule__InstanceCreationExpression__Group__0");
+ put(grammarAccess.getInstanceCreationTupleAccess().getGroup(), "rule__InstanceCreationTuple__Group__0");
+ put(grammarAccess.getInstanceCreationTupleAccess().getGroup_2(), "rule__InstanceCreationTuple__Group_2__0");
+ put(grammarAccess.getInstanceCreationTupleAccess().getGroup_2_1(), "rule__InstanceCreationTuple__Group_2_1__0");
+ put(grammarAccess.getInstanceCreationTupleElementAccess().getGroup(), "rule__InstanceCreationTupleElement__Group__0");
+ put(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getGroup_0(), "rule__SequenceConstructionOrAccessCompletion__Group_0__0");
+ put(grammarAccess.getAccessCompletionAccess().getGroup(), "rule__AccessCompletion__Group__0");
+ put(grammarAccess.getPartialSequenceConstructionCompletionAccess().getGroup(), "rule__PartialSequenceConstructionCompletion__Group__0");
+ put(grammarAccess.getSequenceConstructionExpressionAccess().getGroup(), "rule__SequenceConstructionExpression__Group__0");
+ put(grammarAccess.getSequenceConstructionExpressionAccess().getGroup_2_0(), "rule__SequenceConstructionExpression__Group_2_0__0");
+ put(grammarAccess.getSequenceConstructionExpressionAccess().getGroup_2_1(), "rule__SequenceConstructionExpression__Group_2_1__0");
+ put(grammarAccess.getClassExtentExpressionAccess().getGroup(), "rule__ClassExtentExpression__Group__0");
+ put(grammarAccess.getBlockAccess().getGroup(), "rule__Block__Group__0");
+ put(grammarAccess.getDocumentedStatementAccess().getGroup(), "rule__DocumentedStatement__Group__0");
+ put(grammarAccess.getInlineStatementAccess().getGroup(), "rule__InlineStatement__Group__0");
+ put(grammarAccess.getAnnotatedStatementAccess().getGroup(), "rule__AnnotatedStatement__Group__0");
+ put(grammarAccess.getAnnotationAccess().getGroup(), "rule__Annotation__Group__0");
+ put(grammarAccess.getAnnotationAccess().getGroup_1(), "rule__Annotation__Group_1__0");
+ put(grammarAccess.getAnnotationAccess().getGroup_1_2(), "rule__Annotation__Group_1_2__0");
+ put(grammarAccess.getEmptyStatementAccess().getGroup(), "rule__EmptyStatement__Group__0");
+ put(grammarAccess.getLocalNameDeclarationStatementAccess().getGroup(), "rule__LocalNameDeclarationStatement__Group__0");
+ put(grammarAccess.getLocalNameDeclarationStatementAccess().getGroup_4(), "rule__LocalNameDeclarationStatement__Group_4__0");
+ put(grammarAccess.getIfStatementAccess().getGroup(), "rule__IfStatement__Group__0");
+ put(grammarAccess.getSequentialClausesAccess().getGroup(), "rule__SequentialClauses__Group__0");
+ put(grammarAccess.getSequentialClausesAccess().getGroup_1(), "rule__SequentialClauses__Group_1__0");
+ put(grammarAccess.getConcurrentClausesAccess().getGroup(), "rule__ConcurrentClauses__Group__0");
+ put(grammarAccess.getConcurrentClausesAccess().getGroup_1(), "rule__ConcurrentClauses__Group_1__0");
+ put(grammarAccess.getNonFinalClauseAccess().getGroup(), "rule__NonFinalClause__Group__0");
+ put(grammarAccess.getFinalClauseAccess().getGroup(), "rule__FinalClause__Group__0");
+ put(grammarAccess.getSwitchStatementAccess().getGroup(), "rule__SwitchStatement__Group__0");
+ put(grammarAccess.getSwitchClauseAccess().getGroup(), "rule__SwitchClause__Group__0");
+ put(grammarAccess.getSwitchCaseAccess().getGroup(), "rule__SwitchCase__Group__0");
+ put(grammarAccess.getSwitchDefaultClauseAccess().getGroup(), "rule__SwitchDefaultClause__Group__0");
+ put(grammarAccess.getWhileStatementAccess().getGroup(), "rule__WhileStatement__Group__0");
+ put(grammarAccess.getDoStatementAccess().getGroup(), "rule__DoStatement__Group__0");
+ put(grammarAccess.getForStatementAccess().getGroup(), "rule__ForStatement__Group__0");
+ put(grammarAccess.getForControlAccess().getGroup(), "rule__ForControl__Group__0");
+ put(grammarAccess.getForControlAccess().getGroup_1(), "rule__ForControl__Group_1__0");
+ put(grammarAccess.getLoopVariableDefinitionAccess().getGroup_0(), "rule__LoopVariableDefinition__Group_0__0");
+ put(grammarAccess.getLoopVariableDefinitionAccess().getGroup_0_3(), "rule__LoopVariableDefinition__Group_0_3__0");
+ put(grammarAccess.getLoopVariableDefinitionAccess().getGroup_1(), "rule__LoopVariableDefinition__Group_1__0");
+ put(grammarAccess.getBreakStatementAccess().getGroup(), "rule__BreakStatement__Group__0");
+ put(grammarAccess.getReturnStatementAccess().getGroup(), "rule__ReturnStatement__Group__0");
+ put(grammarAccess.getAcceptStatementAccess().getGroup(), "rule__AcceptStatement__Group__0");
+ put(grammarAccess.getSimpleAcceptStatementCompletionAccess().getGroup(), "rule__SimpleAcceptStatementCompletion__Group__0");
+ put(grammarAccess.getCompoundAcceptStatementCompletionAccess().getGroup(), "rule__CompoundAcceptStatementCompletion__Group__0");
+ put(grammarAccess.getCompoundAcceptStatementCompletionAccess().getGroup_1(), "rule__CompoundAcceptStatementCompletion__Group_1__0");
+ put(grammarAccess.getAcceptBlockAccess().getGroup(), "rule__AcceptBlock__Group__0");
+ put(grammarAccess.getAcceptClauseAccess().getGroup(), "rule__AcceptClause__Group__0");
+ put(grammarAccess.getAcceptClauseAccess().getGroup_2(), "rule__AcceptClause__Group_2__0");
+ put(grammarAccess.getClassifyStatementAccess().getGroup(), "rule__ClassifyStatement__Group__0");
+ put(grammarAccess.getClassificationClauseAccess().getGroup_0(), "rule__ClassificationClause__Group_0__0");
+ put(grammarAccess.getClassificationClauseAccess().getGroup_1(), "rule__ClassificationClause__Group_1__0");
+ put(grammarAccess.getClassificationFromClauseAccess().getGroup(), "rule__ClassificationFromClause__Group__0");
+ put(grammarAccess.getClassificationToClauseAccess().getGroup(), "rule__ClassificationToClause__Group__0");
+ put(grammarAccess.getReclassifyAllClauseAccess().getGroup(), "rule__ReclassifyAllClause__Group__0");
+ put(grammarAccess.getQualifiedNameListAccess().getGroup(), "rule__QualifiedNameList__Group__0");
+ put(grammarAccess.getQualifiedNameListAccess().getGroup_1(), "rule__QualifiedNameList__Group_1__0");
+ put(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getGroup(), "rule__InvocationOrAssignementOrDeclarationStatement__Group__0");
+ put(grammarAccess.getSuperInvocationStatementAccess().getGroup(), "rule__SuperInvocationStatement__Group__0");
+ put(grammarAccess.getThisInvocationStatementAccess().getGroup(), "rule__ThisInvocationStatement__Group__0");
+ put(grammarAccess.getInstanceCreationInvocationStatementAccess().getGroup(), "rule__InstanceCreationInvocationStatement__Group__0");
+ put(grammarAccess.getVariableDeclarationCompletionAccess().getGroup(), "rule__VariableDeclarationCompletion__Group__0");
+ put(grammarAccess.getVariableDeclarationCompletionAccess().getGroup_0(), "rule__VariableDeclarationCompletion__Group_0__0");
+ put(grammarAccess.getAssignmentCompletionAccess().getGroup(), "rule__AssignmentCompletion__Group__0");
+ put(grammarAccess.getTestAccess().getExpressionAssignment_0_1(), "rule__Test__ExpressionAssignment_0_1");
+ put(grammarAccess.getTestAccess().getAssignExpressionAssignment_1_1(), "rule__Test__AssignExpressionAssignment_1_1");
+ put(grammarAccess.getTestAccess().getStatementsAssignment_2_1(), "rule__Test__StatementsAssignment_2_1");
+ put(grammarAccess.getTestAccess().getBlockAssignment_3_1(), "rule__Test__BlockAssignment_3_1");
+ put(grammarAccess.getBOOLEAN_LITERALAccess().getValueAssignment(), "rule__BOOLEAN_LITERAL__ValueAssignment");
+ put(grammarAccess.getINTEGER_LITERALAccess().getValueAssignment(), "rule__INTEGER_LITERAL__ValueAssignment");
+ put(grammarAccess.getUNLIMITED_LITERALAccess().getValueAssignment(), "rule__UNLIMITED_LITERAL__ValueAssignment");
+ put(grammarAccess.getSTRING_LITERALAccess().getValueAssignment(), "rule__STRING_LITERAL__ValueAssignment");
+ put(grammarAccess.getNameExpressionAccess().getPrefixOpAssignment_0_0_0(), "rule__NameExpression__PrefixOpAssignment_0_0_0");
+ put(grammarAccess.getNameExpressionAccess().getPathAssignment_0_0_1(), "rule__NameExpression__PathAssignment_0_0_1");
+ put(grammarAccess.getNameExpressionAccess().getIdAssignment_0_0_2(), "rule__NameExpression__IdAssignment_0_0_2");
+ put(grammarAccess.getNameExpressionAccess().getPathAssignment_0_1_0(), "rule__NameExpression__PathAssignment_0_1_0");
+ put(grammarAccess.getNameExpressionAccess().getIdAssignment_0_1_1(), "rule__NameExpression__IdAssignment_0_1_1");
+ put(grammarAccess.getNameExpressionAccess().getInvocationCompletionAssignment_0_1_2_0(), "rule__NameExpression__InvocationCompletionAssignment_0_1_2_0");
+ put(grammarAccess.getNameExpressionAccess().getSequenceConstructionCompletionAssignment_0_1_2_1(), "rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1");
+ put(grammarAccess.getNameExpressionAccess().getPostfixOpAssignment_0_1_2_2(), "rule__NameExpression__PostfixOpAssignment_0_1_2_2");
+ put(grammarAccess.getNameExpressionAccess().getSuffixAssignment_1(), "rule__NameExpression__SuffixAssignment_1");
+ put(grammarAccess.getQualifiedNamePathAccess().getNamespaceAssignment_0(), "rule__QualifiedNamePath__NamespaceAssignment_0");
+ put(grammarAccess.getUnqualifiedNameAccess().getNameAssignment_0(), "rule__UnqualifiedName__NameAssignment_0");
+ put(grammarAccess.getUnqualifiedNameAccess().getTemplateBindingAssignment_1(), "rule__UnqualifiedName__TemplateBindingAssignment_1");
+ put(grammarAccess.getTemplateBindingAccess().getBindingsAssignment_1(), "rule__TemplateBinding__BindingsAssignment_1");
+ put(grammarAccess.getTemplateBindingAccess().getBindingsAssignment_2_1(), "rule__TemplateBinding__BindingsAssignment_2_1");
+ put(grammarAccess.getNamedTemplateBindingAccess().getFormalAssignment_0(), "rule__NamedTemplateBinding__FormalAssignment_0");
+ put(grammarAccess.getNamedTemplateBindingAccess().getActualAssignment_2(), "rule__NamedTemplateBinding__ActualAssignment_2");
+ put(grammarAccess.getQualifiedNameWithBindingAccess().getIdAssignment_0(), "rule__QualifiedNameWithBinding__IdAssignment_0");
+ put(grammarAccess.getQualifiedNameWithBindingAccess().getBindingAssignment_1(), "rule__QualifiedNameWithBinding__BindingAssignment_1");
+ put(grammarAccess.getQualifiedNameWithBindingAccess().getRemainingAssignment_2_1(), "rule__QualifiedNameWithBinding__RemainingAssignment_2_1");
+ put(grammarAccess.getTupleAccess().getTupleElementsAssignment_2_0(), "rule__Tuple__TupleElementsAssignment_2_0");
+ put(grammarAccess.getTupleAccess().getTupleElementsAssignment_2_1_1(), "rule__Tuple__TupleElementsAssignment_2_1_1");
+ put(grammarAccess.getTupleElementAccess().getArgumentAssignment(), "rule__TupleElement__ArgumentAssignment");
+ put(grammarAccess.getConditionalTestExpressionAccess().getExpAssignment_0(), "rule__ConditionalTestExpression__ExpAssignment_0");
+ put(grammarAccess.getConditionalTestExpressionAccess().getWhenTrueAssignment_1_1(), "rule__ConditionalTestExpression__WhenTrueAssignment_1_1");
+ put(grammarAccess.getConditionalTestExpressionAccess().getWhenFalseAssignment_1_3(), "rule__ConditionalTestExpression__WhenFalseAssignment_1_3");
+ put(grammarAccess.getConditionalOrExpressionAccess().getExpAssignment_0(), "rule__ConditionalOrExpression__ExpAssignment_0");
+ put(grammarAccess.getConditionalOrExpressionAccess().getExpAssignment_1_1(), "rule__ConditionalOrExpression__ExpAssignment_1_1");
+ put(grammarAccess.getConditionalAndExpressionAccess().getExpAssignment_0(), "rule__ConditionalAndExpression__ExpAssignment_0");
+ put(grammarAccess.getConditionalAndExpressionAccess().getExpAssignment_1_1(), "rule__ConditionalAndExpression__ExpAssignment_1_1");
+ put(grammarAccess.getInclusiveOrExpressionAccess().getExpAssignment_0(), "rule__InclusiveOrExpression__ExpAssignment_0");
+ put(grammarAccess.getInclusiveOrExpressionAccess().getExpAssignment_1_1(), "rule__InclusiveOrExpression__ExpAssignment_1_1");
+ put(grammarAccess.getExclusiveOrExpressionAccess().getExpAssignment_0(), "rule__ExclusiveOrExpression__ExpAssignment_0");
+ put(grammarAccess.getExclusiveOrExpressionAccess().getExpAssignment_1_1(), "rule__ExclusiveOrExpression__ExpAssignment_1_1");
+ put(grammarAccess.getAndExpressionAccess().getExpAssignment_0(), "rule__AndExpression__ExpAssignment_0");
+ put(grammarAccess.getAndExpressionAccess().getExpAssignment_1_1(), "rule__AndExpression__ExpAssignment_1_1");
+ put(grammarAccess.getEqualityExpressionAccess().getExpAssignment_0(), "rule__EqualityExpression__ExpAssignment_0");
+ put(grammarAccess.getEqualityExpressionAccess().getOpAssignment_1_0(), "rule__EqualityExpression__OpAssignment_1_0");
+ put(grammarAccess.getEqualityExpressionAccess().getExpAssignment_1_1(), "rule__EqualityExpression__ExpAssignment_1_1");
+ put(grammarAccess.getClassificationExpressionAccess().getExpAssignment_0(), "rule__ClassificationExpression__ExpAssignment_0");
+ put(grammarAccess.getClassificationExpressionAccess().getOpAssignment_1_0(), "rule__ClassificationExpression__OpAssignment_1_0");
+ put(grammarAccess.getClassificationExpressionAccess().getTypeNameAssignment_1_1(), "rule__ClassificationExpression__TypeNameAssignment_1_1");
+ put(grammarAccess.getRelationalExpressionAccess().getLeftAssignment_0(), "rule__RelationalExpression__LeftAssignment_0");
+ put(grammarAccess.getRelationalExpressionAccess().getOpAssignment_1_0(), "rule__RelationalExpression__OpAssignment_1_0");
+ put(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_1(), "rule__RelationalExpression__RightAssignment_1_1");
+ put(grammarAccess.getShiftExpressionAccess().getExpAssignment_0(), "rule__ShiftExpression__ExpAssignment_0");
+ put(grammarAccess.getShiftExpressionAccess().getOpAssignment_1_0(), "rule__ShiftExpression__OpAssignment_1_0");
+ put(grammarAccess.getShiftExpressionAccess().getExpAssignment_1_1(), "rule__ShiftExpression__ExpAssignment_1_1");
+ put(grammarAccess.getAdditiveExpressionAccess().getExpAssignment_0(), "rule__AdditiveExpression__ExpAssignment_0");
+ put(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_0(), "rule__AdditiveExpression__OpAssignment_1_0");
+ put(grammarAccess.getAdditiveExpressionAccess().getExpAssignment_1_1(), "rule__AdditiveExpression__ExpAssignment_1_1");
+ put(grammarAccess.getMultiplicativeExpressionAccess().getExpAssignment_0(), "rule__MultiplicativeExpression__ExpAssignment_0");
+ put(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_0(), "rule__MultiplicativeExpression__OpAssignment_1_0");
+ put(grammarAccess.getMultiplicativeExpressionAccess().getExpAssignment_1_1(), "rule__MultiplicativeExpression__ExpAssignment_1_1");
+ put(grammarAccess.getUnaryExpressionAccess().getOpAssignment_0(), "rule__UnaryExpression__OpAssignment_0");
+ put(grammarAccess.getUnaryExpressionAccess().getExpAssignment_1(), "rule__UnaryExpression__ExpAssignment_1");
+ put(grammarAccess.getPrimaryExpressionAccess().getPrefixAssignment(), "rule__PrimaryExpression__PrefixAssignment");
+ put(grammarAccess.getOperationCallExpressionAccess().getOperationNameAssignment_1(), "rule__OperationCallExpression__OperationNameAssignment_1");
+ put(grammarAccess.getOperationCallExpressionAccess().getTupleAssignment_2(), "rule__OperationCallExpression__TupleAssignment_2");
+ put(grammarAccess.getOperationCallExpressionAccess().getSuffixAssignment_3(), "rule__OperationCallExpression__SuffixAssignment_3");
+ put(grammarAccess.getPropertyCallExpressionAccess().getPropertyNameAssignment_1(), "rule__PropertyCallExpression__PropertyNameAssignment_1");
+ put(grammarAccess.getPropertyCallExpressionAccess().getIndexAssignment_2_1(), "rule__PropertyCallExpression__IndexAssignment_2_1");
+ put(grammarAccess.getPropertyCallExpressionAccess().getSuffixAssignment_3(), "rule__PropertyCallExpression__SuffixAssignment_3");
+ put(grammarAccess.getLinkOperationExpressionAccess().getKindAssignment_1(), "rule__LinkOperationExpression__KindAssignment_1");
+ put(grammarAccess.getLinkOperationExpressionAccess().getTupleAssignment_2(), "rule__LinkOperationExpression__TupleAssignment_2");
+ put(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementAssignment_1(), "rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1");
+ put(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementAssignment_2_1(), "rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1");
+ put(grammarAccess.getLinkOperationTupleElementAccess().getRoleAssignment_0(), "rule__LinkOperationTupleElement__RoleAssignment_0");
+ put(grammarAccess.getLinkOperationTupleElementAccess().getRoleIndexAssignment_1_1(), "rule__LinkOperationTupleElement__RoleIndexAssignment_1_1");
+ put(grammarAccess.getLinkOperationTupleElementAccess().getObjectAssignment_3(), "rule__LinkOperationTupleElement__ObjectAssignment_3");
+ put(grammarAccess.getSequenceOperationExpressionAccess().getOperationNameAssignment_1(), "rule__SequenceOperationExpression__OperationNameAssignment_1");
+ put(grammarAccess.getSequenceOperationExpressionAccess().getTupleAssignment_2(), "rule__SequenceOperationExpression__TupleAssignment_2");
+ put(grammarAccess.getSequenceOperationExpressionAccess().getSuffixAssignment_3(), "rule__SequenceOperationExpression__SuffixAssignment_3");
+ put(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedAssignment_2(), "rule__SequenceReductionExpression__IsOrderedAssignment_2");
+ put(grammarAccess.getSequenceReductionExpressionAccess().getBehaviorAssignment_3(), "rule__SequenceReductionExpression__BehaviorAssignment_3");
+ put(grammarAccess.getSequenceReductionExpressionAccess().getSuffixAssignment_4(), "rule__SequenceReductionExpression__SuffixAssignment_4");
+ put(grammarAccess.getSelectOrRejectOperationAccess().getOpAssignment_1(), "rule__SelectOrRejectOperation__OpAssignment_1");
+ put(grammarAccess.getSelectOrRejectOperationAccess().getNameAssignment_2(), "rule__SelectOrRejectOperation__NameAssignment_2");
+ put(grammarAccess.getSelectOrRejectOperationAccess().getExprAssignment_4(), "rule__SelectOrRejectOperation__ExprAssignment_4");
+ put(grammarAccess.getSelectOrRejectOperationAccess().getSuffixAssignment_6(), "rule__SelectOrRejectOperation__SuffixAssignment_6");
+ put(grammarAccess.getCollectOrIterateOperationAccess().getOpAssignment_1(), "rule__CollectOrIterateOperation__OpAssignment_1");
+ put(grammarAccess.getCollectOrIterateOperationAccess().getNameAssignment_2(), "rule__CollectOrIterateOperation__NameAssignment_2");
+ put(grammarAccess.getCollectOrIterateOperationAccess().getExprAssignment_4(), "rule__CollectOrIterateOperation__ExprAssignment_4");
+ put(grammarAccess.getCollectOrIterateOperationAccess().getSuffixAssignment_6(), "rule__CollectOrIterateOperation__SuffixAssignment_6");
+ put(grammarAccess.getForAllOrExistsOrOneOperationAccess().getOpAssignment_1(), "rule__ForAllOrExistsOrOneOperation__OpAssignment_1");
+ put(grammarAccess.getForAllOrExistsOrOneOperationAccess().getNameAssignment_2(), "rule__ForAllOrExistsOrOneOperation__NameAssignment_2");
+ put(grammarAccess.getForAllOrExistsOrOneOperationAccess().getExprAssignment_4(), "rule__ForAllOrExistsOrOneOperation__ExprAssignment_4");
+ put(grammarAccess.getForAllOrExistsOrOneOperationAccess().getSuffixAssignment_6(), "rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6");
+ put(grammarAccess.getIsUniqueOperationAccess().getNameAssignment_2(), "rule__IsUniqueOperation__NameAssignment_2");
+ put(grammarAccess.getIsUniqueOperationAccess().getExprAssignment_4(), "rule__IsUniqueOperation__ExprAssignment_4");
+ put(grammarAccess.getIsUniqueOperationAccess().getSuffixAssignment_6(), "rule__IsUniqueOperation__SuffixAssignment_6");
+ put(grammarAccess.getParenthesizedExpressionAccess().getExpOrTypeCastAssignment_1(), "rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1");
+ put(grammarAccess.getParenthesizedExpressionAccess().getCastedAssignment_3_0(), "rule__ParenthesizedExpression__CastedAssignment_3_0");
+ put(grammarAccess.getParenthesizedExpressionAccess().getSuffixAssignment_3_1(), "rule__ParenthesizedExpression__SuffixAssignment_3_1");
+ put(grammarAccess.getThisExpressionAccess().getSuffixAssignment_2(), "rule__ThisExpression__SuffixAssignment_2");
+ put(grammarAccess.getSuperInvocationExpressionAccess().getTupleAssignment_1_0(), "rule__SuperInvocationExpression__TupleAssignment_1_0");
+ put(grammarAccess.getSuperInvocationExpressionAccess().getOperationNameAssignment_1_1_1(), "rule__SuperInvocationExpression__OperationNameAssignment_1_1_1");
+ put(grammarAccess.getSuperInvocationExpressionAccess().getTupleAssignment_1_1_2(), "rule__SuperInvocationExpression__TupleAssignment_1_1_2");
+ put(grammarAccess.getInstanceCreationExpressionAccess().getConstructorAssignment_1(), "rule__InstanceCreationExpression__ConstructorAssignment_1");
+ put(grammarAccess.getInstanceCreationExpressionAccess().getTupleAssignment_2(), "rule__InstanceCreationExpression__TupleAssignment_2");
+ put(grammarAccess.getInstanceCreationExpressionAccess().getSuffixAssignment_3(), "rule__InstanceCreationExpression__SuffixAssignment_3");
+ put(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementAssignment_2_0(), "rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0");
+ put(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementAssignment_2_1_1(), "rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1");
+ put(grammarAccess.getInstanceCreationTupleElementAccess().getRoleAssignment_0(), "rule__InstanceCreationTupleElement__RoleAssignment_0");
+ put(grammarAccess.getInstanceCreationTupleElementAccess().getObjectAssignment_2(), "rule__InstanceCreationTupleElement__ObjectAssignment_2");
+ put(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorAssignment_0_0(), "rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0");
+ put(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAccessCompletionAssignment_0_1_0(), "rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0");
+ put(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getSequenceCompletionAssignment_0_1_1(), "rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1");
+ put(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getExpressionAssignment_1(), "rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1");
+ put(grammarAccess.getAccessCompletionAccess().getAccessIndexAssignment_0(), "rule__AccessCompletion__AccessIndexAssignment_0");
+ put(grammarAccess.getPartialSequenceConstructionCompletionAccess().getExpressionAssignment_1(), "rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1");
+ put(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementAssignment_1(), "rule__SequenceConstructionExpression__SequenceElementAssignment_1");
+ put(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementAssignment_2_0_1(), "rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1");
+ put(grammarAccess.getSequenceConstructionExpressionAccess().getRangeUpperAssignment_2_1_1(), "rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1");
+ put(grammarAccess.getBlockAccess().getSequenceAssignment_2(), "rule__Block__SequenceAssignment_2");
+ put(grammarAccess.getStatementSequenceAccess().getStatementsAssignment(), "rule__StatementSequence__StatementsAssignment");
+ put(grammarAccess.getDocumentedStatementAccess().getCommentAssignment_0(), "rule__DocumentedStatement__CommentAssignment_0");
+ put(grammarAccess.getDocumentedStatementAccess().getStatementAssignment_1(), "rule__DocumentedStatement__StatementAssignment_1");
+ put(grammarAccess.getInlineStatementAccess().getLangageNameAssignment_3(), "rule__InlineStatement__LangageNameAssignment_3");
+ put(grammarAccess.getInlineStatementAccess().getBodyAssignment_5(), "rule__InlineStatement__BodyAssignment_5");
+ put(grammarAccess.getAnnotatedStatementAccess().getAnnotationAssignment_1(), "rule__AnnotatedStatement__AnnotationAssignment_1");
+ put(grammarAccess.getAnnotatedStatementAccess().getStatementAssignment_2(), "rule__AnnotatedStatement__StatementAssignment_2");
+ put(grammarAccess.getAnnotationAccess().getKindAssignment_0(), "rule__Annotation__KindAssignment_0");
+ put(grammarAccess.getAnnotationAccess().getArgsAssignment_1_1(), "rule__Annotation__ArgsAssignment_1_1");
+ put(grammarAccess.getAnnotationAccess().getArgsAssignment_1_2_1(), "rule__Annotation__ArgsAssignment_1_2_1");
+ put(grammarAccess.getBlockStatementAccess().getBlockAssignment(), "rule__BlockStatement__BlockAssignment");
+ put(grammarAccess.getLocalNameDeclarationStatementAccess().getVarNameAssignment_1(), "rule__LocalNameDeclarationStatement__VarNameAssignment_1");
+ put(grammarAccess.getLocalNameDeclarationStatementAccess().getTypeAssignment_3(), "rule__LocalNameDeclarationStatement__TypeAssignment_3");
+ put(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorAssignment_4_0(), "rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0");
+ put(grammarAccess.getLocalNameDeclarationStatementAccess().getInitAssignment_6(), "rule__LocalNameDeclarationStatement__InitAssignment_6");
+ put(grammarAccess.getIfStatementAccess().getSequentialClaussesAssignment_1(), "rule__IfStatement__SequentialClaussesAssignment_1");
+ put(grammarAccess.getIfStatementAccess().getFinalClauseAssignment_2(), "rule__IfStatement__FinalClauseAssignment_2");
+ put(grammarAccess.getSequentialClausesAccess().getConccurentClausesAssignment_0(), "rule__SequentialClauses__ConccurentClausesAssignment_0");
+ put(grammarAccess.getSequentialClausesAccess().getConccurentClausesAssignment_1_2(), "rule__SequentialClauses__ConccurentClausesAssignment_1_2");
+ put(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseAssignment_0(), "rule__ConcurrentClauses__NonFinalClauseAssignment_0");
+ put(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseAssignment_1_2(), "rule__ConcurrentClauses__NonFinalClauseAssignment_1_2");
+ put(grammarAccess.getNonFinalClauseAccess().getConditionAssignment_1(), "rule__NonFinalClause__ConditionAssignment_1");
+ put(grammarAccess.getNonFinalClauseAccess().getBlockAssignment_3(), "rule__NonFinalClause__BlockAssignment_3");
+ put(grammarAccess.getFinalClauseAccess().getBlockAssignment_1(), "rule__FinalClause__BlockAssignment_1");
+ put(grammarAccess.getSwitchStatementAccess().getExpressionAssignment_2(), "rule__SwitchStatement__ExpressionAssignment_2");
+ put(grammarAccess.getSwitchStatementAccess().getSwitchClauseAssignment_5(), "rule__SwitchStatement__SwitchClauseAssignment_5");
+ put(grammarAccess.getSwitchStatementAccess().getDefaultClauseAssignment_6(), "rule__SwitchStatement__DefaultClauseAssignment_6");
+ put(grammarAccess.getSwitchClauseAccess().getSwitchCaseAssignment_0(), "rule__SwitchClause__SwitchCaseAssignment_0");
+ put(grammarAccess.getSwitchClauseAccess().getSwitchCaseAssignment_1(), "rule__SwitchClause__SwitchCaseAssignment_1");
+ put(grammarAccess.getSwitchClauseAccess().getStatementSequenceAssignment_2(), "rule__SwitchClause__StatementSequenceAssignment_2");
+ put(grammarAccess.getSwitchCaseAccess().getExpressionAssignment_1(), "rule__SwitchCase__ExpressionAssignment_1");
+ put(grammarAccess.getSwitchDefaultClauseAccess().getStatementSequenceAssignment_2(), "rule__SwitchDefaultClause__StatementSequenceAssignment_2");
+ put(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementAssignment(), "rule__NonEmptyStatementSequence__StatementAssignment");
+ put(grammarAccess.getWhileStatementAccess().getConditionAssignment_2(), "rule__WhileStatement__ConditionAssignment_2");
+ put(grammarAccess.getWhileStatementAccess().getBlockAssignment_4(), "rule__WhileStatement__BlockAssignment_4");
+ put(grammarAccess.getDoStatementAccess().getBlockAssignment_1(), "rule__DoStatement__BlockAssignment_1");
+ put(grammarAccess.getDoStatementAccess().getConditionAssignment_4(), "rule__DoStatement__ConditionAssignment_4");
+ put(grammarAccess.getForStatementAccess().getControlAssignment_2(), "rule__ForStatement__ControlAssignment_2");
+ put(grammarAccess.getForStatementAccess().getBlockAssignment_4(), "rule__ForStatement__BlockAssignment_4");
+ put(grammarAccess.getForControlAccess().getLoopVariableDefinitionAssignment_0(), "rule__ForControl__LoopVariableDefinitionAssignment_0");
+ put(grammarAccess.getForControlAccess().getLoopVariableDefinitionAssignment_1_1(), "rule__ForControl__LoopVariableDefinitionAssignment_1_1");
+ put(grammarAccess.getLoopVariableDefinitionAccess().getNameAssignment_0_0(), "rule__LoopVariableDefinition__NameAssignment_0_0");
+ put(grammarAccess.getLoopVariableDefinitionAccess().getExpression1Assignment_0_2(), "rule__LoopVariableDefinition__Expression1Assignment_0_2");
+ put(grammarAccess.getLoopVariableDefinitionAccess().getExpression2Assignment_0_3_1(), "rule__LoopVariableDefinition__Expression2Assignment_0_3_1");
+ put(grammarAccess.getLoopVariableDefinitionAccess().getTypeAssignment_1_0(), "rule__LoopVariableDefinition__TypeAssignment_1_0");
+ put(grammarAccess.getLoopVariableDefinitionAccess().getNameAssignment_1_1(), "rule__LoopVariableDefinition__NameAssignment_1_1");
+ put(grammarAccess.getLoopVariableDefinitionAccess().getExpressionAssignment_1_3(), "rule__LoopVariableDefinition__ExpressionAssignment_1_3");
+ put(grammarAccess.getReturnStatementAccess().getExpressionAssignment_1(), "rule__ReturnStatement__ExpressionAssignment_1");
+ put(grammarAccess.getAcceptStatementAccess().getClauseAssignment_0(), "rule__AcceptStatement__ClauseAssignment_0");
+ put(grammarAccess.getAcceptStatementAccess().getSimpleAcceptAssignment_1_0(), "rule__AcceptStatement__SimpleAcceptAssignment_1_0");
+ put(grammarAccess.getAcceptStatementAccess().getCompoundAcceptAssignment_1_1(), "rule__AcceptStatement__CompoundAcceptAssignment_1_1");
+ put(grammarAccess.getCompoundAcceptStatementCompletionAccess().getBlockAssignment_0(), "rule__CompoundAcceptStatementCompletion__BlockAssignment_0");
+ put(grammarAccess.getCompoundAcceptStatementCompletionAccess().getAcceptBlockAssignment_1_1(), "rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1");
+ put(grammarAccess.getAcceptBlockAccess().getClauseAssignment_0(), "rule__AcceptBlock__ClauseAssignment_0");
+ put(grammarAccess.getAcceptBlockAccess().getBlockAssignment_1(), "rule__AcceptBlock__BlockAssignment_1");
+ put(grammarAccess.getAcceptClauseAccess().getNameAssignment_2_0(), "rule__AcceptClause__NameAssignment_2_0");
+ put(grammarAccess.getAcceptClauseAccess().getQualifiedNameListAssignment_3(), "rule__AcceptClause__QualifiedNameListAssignment_3");
+ put(grammarAccess.getClassifyStatementAccess().getExpressionAssignment_1(), "rule__ClassifyStatement__ExpressionAssignment_1");
+ put(grammarAccess.getClassifyStatementAccess().getClauseAssignment_2(), "rule__ClassifyStatement__ClauseAssignment_2");
+ put(grammarAccess.getClassificationClauseAccess().getClassifyFromClauseAssignment_0_0(), "rule__ClassificationClause__ClassifyFromClauseAssignment_0_0");
+ put(grammarAccess.getClassificationClauseAccess().getClassifyToClauseAssignment_0_1(), "rule__ClassificationClause__ClassifyToClauseAssignment_0_1");
+ put(grammarAccess.getClassificationClauseAccess().getReclassyAllClauseAssignment_1_0(), "rule__ClassificationClause__ReclassyAllClauseAssignment_1_0");
+ put(grammarAccess.getClassificationClauseAccess().getClassifyToClauseAssignment_1_1(), "rule__ClassificationClause__ClassifyToClauseAssignment_1_1");
+ put(grammarAccess.getClassificationFromClauseAccess().getQualifiedNameListAssignment_1(), "rule__ClassificationFromClause__QualifiedNameListAssignment_1");
+ put(grammarAccess.getClassificationToClauseAccess().getQualifiedNameListAssignment_1(), "rule__ClassificationToClause__QualifiedNameListAssignment_1");
+ put(grammarAccess.getQualifiedNameListAccess().getQualifiedNameAssignment_0(), "rule__QualifiedNameList__QualifiedNameAssignment_0");
+ put(grammarAccess.getQualifiedNameListAccess().getQualifiedNameAssignment_1_1(), "rule__QualifiedNameList__QualifiedNameAssignment_1_1");
+ put(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getTypePart_OR_assignedPart_OR_invocationPartAssignment_0(), "rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0");
+ put(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getVariableDeclarationCompletionAssignment_1_0(), "rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0");
+ put(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAssignmentCompletionAssignment_1_1(), "rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1");
+ put(grammarAccess.getSuperInvocationStatementAccess().get_superAssignment_0(), "rule__SuperInvocationStatement___superAssignment_0");
+ put(grammarAccess.getThisInvocationStatementAccess().get_thisAssignment_0(), "rule__ThisInvocationStatement___thisAssignment_0");
+ put(grammarAccess.getThisInvocationStatementAccess().getAssignmentCompletionAssignment_1(), "rule__ThisInvocationStatement__AssignmentCompletionAssignment_1");
+ put(grammarAccess.getInstanceCreationInvocationStatementAccess().get_newAssignment_0(), "rule__InstanceCreationInvocationStatement___newAssignment_0");
+ put(grammarAccess.getVariableDeclarationCompletionAccess().getMultiplicityIndicatorAssignment_0_0(), "rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0");
+ put(grammarAccess.getVariableDeclarationCompletionAccess().getVariableNameAssignment_1(), "rule__VariableDeclarationCompletion__VariableNameAssignment_1");
+ put(grammarAccess.getVariableDeclarationCompletionAccess().getInitValueAssignment_2(), "rule__VariableDeclarationCompletion__InitValueAssignment_2");
+ put(grammarAccess.getAssignmentCompletionAccess().getOpAssignment_0(), "rule__AssignmentCompletion__OpAssignment_0");
+ put(grammarAccess.getAssignmentCompletionAccess().getRightHandSideAssignment_1(), "rule__AssignmentCompletion__RightHandSideAssignment_1");
+ }
+ };
+ }
+ return nameMappings.get(element);
+ }
+
+ @Override
+ protected Collection<FollowElement> getFollowElements(AbstractInternalContentAssistParser parser) {
+ try {
+ org.eclipse.papyrus.alf.ui.contentassist.antlr.internal.InternalAlfParser typedParser = (org.eclipse.papyrus.alf.ui.contentassist.antlr.internal.InternalAlfParser) parser;
+ typedParser.entryRuleTest();
+ return typedParser.getFollowElements();
+ } catch(RecognitionException ex) {
+ throw new RuntimeException(ex);
+ }
+ }
+
+ @Override
+ protected String[] getInitialHiddenTokens() {
+ return new String[] { "RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT" };
+ }
+
+ public AlfGrammarAccess getGrammarAccess() {
+ return this.grammarAccess;
+ }
+
+ public void setGrammarAccess(AlfGrammarAccess grammarAccess) {
+ this.grammarAccess = grammarAccess;
+ }
+}
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g
new file mode 100644
index 00000000000..e04b09fc02a
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g
@@ -0,0 +1,19052 @@
+/*
+* generated by Xtext
+*/
+grammar InternalAlf;
+
+options {
+ superClass=AbstractInternalContentAssistParser;
+
+}
+
+@lexer::header {
+package org.eclipse.papyrus.alf.ui.contentassist.antlr.internal;
+
+// Hack: Use our own Lexer superclass by means of import.
+// Currently there is no other way to specify the superclass for the lexer.
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.Lexer;
+}
+
+@parser::header {
+package org.eclipse.papyrus.alf.ui.contentassist.antlr.internal;
+
+import java.io.InputStream;
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.*;
+import org.eclipse.xtext.parser.impl.*;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.DFA;
+import org.eclipse.papyrus.alf.services.AlfGrammarAccess;
+
+}
+
+@parser::members {
+
+ private AlfGrammarAccess grammarAccess;
+
+ public void setGrammarAccess(AlfGrammarAccess grammarAccess) {
+ this.grammarAccess = grammarAccess;
+ }
+
+ @Override
+ protected Grammar getGrammar() {
+ return grammarAccess.getGrammar();
+ }
+
+ @Override
+ protected String getValueForTokenName(String tokenName) {
+ return tokenName;
+ }
+
+}
+
+
+
+
+// Entry rule entryRuleTest
+entryRuleTest
+:
+{ before(grammarAccess.getTestRule()); }
+ ruleTest
+{ after(grammarAccess.getTestRule()); }
+ EOF
+;
+
+// Rule Test
+ruleTest
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTestAccess().getGroup()); }
+(rule__Test__Group__0)
+{ after(grammarAccess.getTestAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLITERAL
+entryRuleLITERAL
+:
+{ before(grammarAccess.getLITERALRule()); }
+ ruleLITERAL
+{ after(grammarAccess.getLITERALRule()); }
+ EOF
+;
+
+// Rule LITERAL
+ruleLITERAL
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getLITERALAccess().getAlternatives()); }
+(rule__LITERAL__Alternatives)
+{ after(grammarAccess.getLITERALAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleBOOLEAN_LITERAL
+entryRuleBOOLEAN_LITERAL
+:
+{ before(grammarAccess.getBOOLEAN_LITERALRule()); }
+ ruleBOOLEAN_LITERAL
+{ after(grammarAccess.getBOOLEAN_LITERALRule()); }
+ EOF
+;
+
+// Rule BOOLEAN_LITERAL
+ruleBOOLEAN_LITERAL
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getBOOLEAN_LITERALAccess().getValueAssignment()); }
+(rule__BOOLEAN_LITERAL__ValueAssignment)
+{ after(grammarAccess.getBOOLEAN_LITERALAccess().getValueAssignment()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNUMBER_LITERAL
+entryRuleNUMBER_LITERAL
+:
+{ before(grammarAccess.getNUMBER_LITERALRule()); }
+ ruleNUMBER_LITERAL
+{ after(grammarAccess.getNUMBER_LITERALRule()); }
+ EOF
+;
+
+// Rule NUMBER_LITERAL
+ruleNUMBER_LITERAL
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getNUMBER_LITERALAccess().getAlternatives()); }
+(rule__NUMBER_LITERAL__Alternatives)
+{ after(grammarAccess.getNUMBER_LITERALAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleINTEGER_LITERAL
+entryRuleINTEGER_LITERAL
+:
+{ before(grammarAccess.getINTEGER_LITERALRule()); }
+ ruleINTEGER_LITERAL
+{ after(grammarAccess.getINTEGER_LITERALRule()); }
+ EOF
+;
+
+// Rule INTEGER_LITERAL
+ruleINTEGER_LITERAL
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getINTEGER_LITERALAccess().getValueAssignment()); }
+(rule__INTEGER_LITERAL__ValueAssignment)
+{ after(grammarAccess.getINTEGER_LITERALAccess().getValueAssignment()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleUNLIMITED_LITERAL
+entryRuleUNLIMITED_LITERAL
+:
+{ before(grammarAccess.getUNLIMITED_LITERALRule()); }
+ ruleUNLIMITED_LITERAL
+{ after(grammarAccess.getUNLIMITED_LITERALRule()); }
+ EOF
+;
+
+// Rule UNLIMITED_LITERAL
+ruleUNLIMITED_LITERAL
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getUNLIMITED_LITERALAccess().getValueAssignment()); }
+(rule__UNLIMITED_LITERAL__ValueAssignment)
+{ after(grammarAccess.getUNLIMITED_LITERALAccess().getValueAssignment()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSTRING_LITERAL
+entryRuleSTRING_LITERAL
+:
+{ before(grammarAccess.getSTRING_LITERALRule()); }
+ ruleSTRING_LITERAL
+{ after(grammarAccess.getSTRING_LITERALRule()); }
+ EOF
+;
+
+// Rule STRING_LITERAL
+ruleSTRING_LITERAL
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSTRING_LITERALAccess().getValueAssignment()); }
+(rule__STRING_LITERAL__ValueAssignment)
+{ after(grammarAccess.getSTRING_LITERALAccess().getValueAssignment()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNameExpression
+entryRuleNameExpression
+:
+{ before(grammarAccess.getNameExpressionRule()); }
+ ruleNameExpression
+{ after(grammarAccess.getNameExpressionRule()); }
+ EOF
+;
+
+// Rule NameExpression
+ruleNameExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getNameExpressionAccess().getGroup()); }
+(rule__NameExpression__Group__0)
+{ after(grammarAccess.getNameExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleQualifiedNamePath
+entryRuleQualifiedNamePath
+:
+{ before(grammarAccess.getQualifiedNamePathRule()); }
+ ruleQualifiedNamePath
+{ after(grammarAccess.getQualifiedNamePathRule()); }
+ EOF
+;
+
+// Rule QualifiedNamePath
+ruleQualifiedNamePath
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+(
+{ before(grammarAccess.getQualifiedNamePathAccess().getGroup()); }
+(rule__QualifiedNamePath__Group__0)
+{ after(grammarAccess.getQualifiedNamePathAccess().getGroup()); }
+)
+(
+{ before(grammarAccess.getQualifiedNamePathAccess().getGroup()); }
+(rule__QualifiedNamePath__Group__0)*
+{ after(grammarAccess.getQualifiedNamePathAccess().getGroup()); }
+)
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleUnqualifiedName
+entryRuleUnqualifiedName
+:
+{ before(grammarAccess.getUnqualifiedNameRule()); }
+ ruleUnqualifiedName
+{ after(grammarAccess.getUnqualifiedNameRule()); }
+ EOF
+;
+
+// Rule UnqualifiedName
+ruleUnqualifiedName
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getUnqualifiedNameAccess().getGroup()); }
+(rule__UnqualifiedName__Group__0)
+{ after(grammarAccess.getUnqualifiedNameAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTemplateBinding
+entryRuleTemplateBinding
+:
+{ before(grammarAccess.getTemplateBindingRule()); }
+ ruleTemplateBinding
+{ after(grammarAccess.getTemplateBindingRule()); }
+ EOF
+;
+
+// Rule TemplateBinding
+ruleTemplateBinding
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTemplateBindingAccess().getGroup()); }
+(rule__TemplateBinding__Group__0)
+{ after(grammarAccess.getTemplateBindingAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNamedTemplateBinding
+entryRuleNamedTemplateBinding
+:
+{ before(grammarAccess.getNamedTemplateBindingRule()); }
+ ruleNamedTemplateBinding
+{ after(grammarAccess.getNamedTemplateBindingRule()); }
+ EOF
+;
+
+// Rule NamedTemplateBinding
+ruleNamedTemplateBinding
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getNamedTemplateBindingAccess().getGroup()); }
+(rule__NamedTemplateBinding__Group__0)
+{ after(grammarAccess.getNamedTemplateBindingAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleQualifiedNameWithBinding
+entryRuleQualifiedNameWithBinding
+:
+{ before(grammarAccess.getQualifiedNameWithBindingRule()); }
+ ruleQualifiedNameWithBinding
+{ after(grammarAccess.getQualifiedNameWithBindingRule()); }
+ EOF
+;
+
+// Rule QualifiedNameWithBinding
+ruleQualifiedNameWithBinding
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getGroup()); }
+(rule__QualifiedNameWithBinding__Group__0)
+{ after(grammarAccess.getQualifiedNameWithBindingAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTuple
+entryRuleTuple
+:
+{ before(grammarAccess.getTupleRule()); }
+ ruleTuple
+{ after(grammarAccess.getTupleRule()); }
+ EOF
+;
+
+// Rule Tuple
+ruleTuple
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTupleAccess().getGroup()); }
+(rule__Tuple__Group__0)
+{ after(grammarAccess.getTupleAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTupleElement
+entryRuleTupleElement
+:
+{ before(grammarAccess.getTupleElementRule()); }
+ ruleTupleElement
+{ after(grammarAccess.getTupleElementRule()); }
+ EOF
+;
+
+// Rule TupleElement
+ruleTupleElement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTupleElementAccess().getArgumentAssignment()); }
+(rule__TupleElement__ArgumentAssignment)
+{ after(grammarAccess.getTupleElementAccess().getArgumentAssignment()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleExpression
+entryRuleExpression
+:
+{ before(grammarAccess.getExpressionRule()); }
+ ruleExpression
+{ after(grammarAccess.getExpressionRule()); }
+ EOF
+;
+
+// Rule Expression
+ruleExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getExpressionAccess().getConditionalTestExpressionParserRuleCall()); }
+ ruleConditionalTestExpression
+{ after(grammarAccess.getExpressionAccess().getConditionalTestExpressionParserRuleCall()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleConditionalTestExpression
+entryRuleConditionalTestExpression
+:
+{ before(grammarAccess.getConditionalTestExpressionRule()); }
+ ruleConditionalTestExpression
+{ after(grammarAccess.getConditionalTestExpressionRule()); }
+ EOF
+;
+
+// Rule ConditionalTestExpression
+ruleConditionalTestExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getGroup()); }
+(rule__ConditionalTestExpression__Group__0)
+{ after(grammarAccess.getConditionalTestExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleConditionalOrExpression
+entryRuleConditionalOrExpression
+:
+{ before(grammarAccess.getConditionalOrExpressionRule()); }
+ ruleConditionalOrExpression
+{ after(grammarAccess.getConditionalOrExpressionRule()); }
+ EOF
+;
+
+// Rule ConditionalOrExpression
+ruleConditionalOrExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getConditionalOrExpressionAccess().getGroup()); }
+(rule__ConditionalOrExpression__Group__0)
+{ after(grammarAccess.getConditionalOrExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleConditionalAndExpression
+entryRuleConditionalAndExpression
+:
+{ before(grammarAccess.getConditionalAndExpressionRule()); }
+ ruleConditionalAndExpression
+{ after(grammarAccess.getConditionalAndExpressionRule()); }
+ EOF
+;
+
+// Rule ConditionalAndExpression
+ruleConditionalAndExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getConditionalAndExpressionAccess().getGroup()); }
+(rule__ConditionalAndExpression__Group__0)
+{ after(grammarAccess.getConditionalAndExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleInclusiveOrExpression
+entryRuleInclusiveOrExpression
+:
+{ before(grammarAccess.getInclusiveOrExpressionRule()); }
+ ruleInclusiveOrExpression
+{ after(grammarAccess.getInclusiveOrExpressionRule()); }
+ EOF
+;
+
+// Rule InclusiveOrExpression
+ruleInclusiveOrExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getInclusiveOrExpressionAccess().getGroup()); }
+(rule__InclusiveOrExpression__Group__0)
+{ after(grammarAccess.getInclusiveOrExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleExclusiveOrExpression
+entryRuleExclusiveOrExpression
+:
+{ before(grammarAccess.getExclusiveOrExpressionRule()); }
+ ruleExclusiveOrExpression
+{ after(grammarAccess.getExclusiveOrExpressionRule()); }
+ EOF
+;
+
+// Rule ExclusiveOrExpression
+ruleExclusiveOrExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getExclusiveOrExpressionAccess().getGroup()); }
+(rule__ExclusiveOrExpression__Group__0)
+{ after(grammarAccess.getExclusiveOrExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAndExpression
+entryRuleAndExpression
+:
+{ before(grammarAccess.getAndExpressionRule()); }
+ ruleAndExpression
+{ after(grammarAccess.getAndExpressionRule()); }
+ EOF
+;
+
+// Rule AndExpression
+ruleAndExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getAndExpressionAccess().getGroup()); }
+(rule__AndExpression__Group__0)
+{ after(grammarAccess.getAndExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleEqualityExpression
+entryRuleEqualityExpression
+:
+{ before(grammarAccess.getEqualityExpressionRule()); }
+ ruleEqualityExpression
+{ after(grammarAccess.getEqualityExpressionRule()); }
+ EOF
+;
+
+// Rule EqualityExpression
+ruleEqualityExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getGroup()); }
+(rule__EqualityExpression__Group__0)
+{ after(grammarAccess.getEqualityExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleClassificationExpression
+entryRuleClassificationExpression
+:
+{ before(grammarAccess.getClassificationExpressionRule()); }
+ ruleClassificationExpression
+{ after(grammarAccess.getClassificationExpressionRule()); }
+ EOF
+;
+
+// Rule ClassificationExpression
+ruleClassificationExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getGroup()); }
+(rule__ClassificationExpression__Group__0)
+{ after(grammarAccess.getClassificationExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleRelationalExpression
+entryRuleRelationalExpression
+:
+{ before(grammarAccess.getRelationalExpressionRule()); }
+ ruleRelationalExpression
+{ after(grammarAccess.getRelationalExpressionRule()); }
+ EOF
+;
+
+// Rule RelationalExpression
+ruleRelationalExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getRelationalExpressionAccess().getGroup()); }
+(rule__RelationalExpression__Group__0)
+{ after(grammarAccess.getRelationalExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleShiftExpression
+entryRuleShiftExpression
+:
+{ before(grammarAccess.getShiftExpressionRule()); }
+ ruleShiftExpression
+{ after(grammarAccess.getShiftExpressionRule()); }
+ EOF
+;
+
+// Rule ShiftExpression
+ruleShiftExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getShiftExpressionAccess().getGroup()); }
+(rule__ShiftExpression__Group__0)
+{ after(grammarAccess.getShiftExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAdditiveExpression
+entryRuleAdditiveExpression
+:
+{ before(grammarAccess.getAdditiveExpressionRule()); }
+ ruleAdditiveExpression
+{ after(grammarAccess.getAdditiveExpressionRule()); }
+ EOF
+;
+
+// Rule AdditiveExpression
+ruleAdditiveExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getAdditiveExpressionAccess().getGroup()); }
+(rule__AdditiveExpression__Group__0)
+{ after(grammarAccess.getAdditiveExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleMultiplicativeExpression
+entryRuleMultiplicativeExpression
+:
+{ before(grammarAccess.getMultiplicativeExpressionRule()); }
+ ruleMultiplicativeExpression
+{ after(grammarAccess.getMultiplicativeExpressionRule()); }
+ EOF
+;
+
+// Rule MultiplicativeExpression
+ruleMultiplicativeExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); }
+(rule__MultiplicativeExpression__Group__0)
+{ after(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleUnaryExpression
+entryRuleUnaryExpression
+:
+{ before(grammarAccess.getUnaryExpressionRule()); }
+ ruleUnaryExpression
+{ after(grammarAccess.getUnaryExpressionRule()); }
+ EOF
+;
+
+// Rule UnaryExpression
+ruleUnaryExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getUnaryExpressionAccess().getGroup()); }
+(rule__UnaryExpression__Group__0)
+{ after(grammarAccess.getUnaryExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePrimaryExpression
+entryRulePrimaryExpression
+:
+{ before(grammarAccess.getPrimaryExpressionRule()); }
+ rulePrimaryExpression
+{ after(grammarAccess.getPrimaryExpressionRule()); }
+ EOF
+;
+
+// Rule PrimaryExpression
+rulePrimaryExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getPrefixAssignment()); }
+(rule__PrimaryExpression__PrefixAssignment)
+{ after(grammarAccess.getPrimaryExpressionAccess().getPrefixAssignment()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSuffixExpression
+entryRuleSuffixExpression
+:
+{ before(grammarAccess.getSuffixExpressionRule()); }
+ ruleSuffixExpression
+{ after(grammarAccess.getSuffixExpressionRule()); }
+ EOF
+;
+
+// Rule SuffixExpression
+ruleSuffixExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSuffixExpressionAccess().getAlternatives()); }
+(rule__SuffixExpression__Alternatives)
+{ after(grammarAccess.getSuffixExpressionAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleOperationCallExpression
+entryRuleOperationCallExpression
+:
+{ before(grammarAccess.getOperationCallExpressionRule()); }
+ ruleOperationCallExpression
+{ after(grammarAccess.getOperationCallExpressionRule()); }
+ EOF
+;
+
+// Rule OperationCallExpression
+ruleOperationCallExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getOperationCallExpressionAccess().getGroup()); }
+(rule__OperationCallExpression__Group__0)
+{ after(grammarAccess.getOperationCallExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyCallExpression
+entryRulePropertyCallExpression
+:
+{ before(grammarAccess.getPropertyCallExpressionRule()); }
+ rulePropertyCallExpression
+{ after(grammarAccess.getPropertyCallExpressionRule()); }
+ EOF
+;
+
+// Rule PropertyCallExpression
+rulePropertyCallExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getGroup()); }
+(rule__PropertyCallExpression__Group__0)
+{ after(grammarAccess.getPropertyCallExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLinkOperationExpression
+entryRuleLinkOperationExpression
+:
+{ before(grammarAccess.getLinkOperationExpressionRule()); }
+ ruleLinkOperationExpression
+{ after(grammarAccess.getLinkOperationExpressionRule()); }
+ EOF
+;
+
+// Rule LinkOperationExpression
+ruleLinkOperationExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getLinkOperationExpressionAccess().getGroup()); }
+(rule__LinkOperationExpression__Group__0)
+{ after(grammarAccess.getLinkOperationExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLinkOperationTuple
+entryRuleLinkOperationTuple
+:
+{ before(grammarAccess.getLinkOperationTupleRule()); }
+ ruleLinkOperationTuple
+{ after(grammarAccess.getLinkOperationTupleRule()); }
+ EOF
+;
+
+// Rule LinkOperationTuple
+ruleLinkOperationTuple
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getGroup()); }
+(rule__LinkOperationTuple__Group__0)
+{ after(grammarAccess.getLinkOperationTupleAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLinkOperationTupleElement
+entryRuleLinkOperationTupleElement
+:
+{ before(grammarAccess.getLinkOperationTupleElementRule()); }
+ ruleLinkOperationTupleElement
+{ after(grammarAccess.getLinkOperationTupleElementRule()); }
+ EOF
+;
+
+// Rule LinkOperationTupleElement
+ruleLinkOperationTupleElement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getGroup()); }
+(rule__LinkOperationTupleElement__Group__0)
+{ after(grammarAccess.getLinkOperationTupleElementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSequenceOperationExpression
+entryRuleSequenceOperationExpression
+:
+{ before(grammarAccess.getSequenceOperationExpressionRule()); }
+ ruleSequenceOperationExpression
+{ after(grammarAccess.getSequenceOperationExpressionRule()); }
+ EOF
+;
+
+// Rule SequenceOperationExpression
+ruleSequenceOperationExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSequenceOperationExpressionAccess().getGroup()); }
+(rule__SequenceOperationExpression__Group__0)
+{ after(grammarAccess.getSequenceOperationExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSequenceReductionExpression
+entryRuleSequenceReductionExpression
+:
+{ before(grammarAccess.getSequenceReductionExpressionRule()); }
+ ruleSequenceReductionExpression
+{ after(grammarAccess.getSequenceReductionExpressionRule()); }
+ EOF
+;
+
+// Rule SequenceReductionExpression
+ruleSequenceReductionExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getGroup()); }
+(rule__SequenceReductionExpression__Group__0)
+{ after(grammarAccess.getSequenceReductionExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSequenceExpansionExpression
+entryRuleSequenceExpansionExpression
+:
+{ before(grammarAccess.getSequenceExpansionExpressionRule()); }
+ ruleSequenceExpansionExpression
+{ after(grammarAccess.getSequenceExpansionExpressionRule()); }
+ EOF
+;
+
+// Rule SequenceExpansionExpression
+ruleSequenceExpansionExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSequenceExpansionExpressionAccess().getAlternatives()); }
+(rule__SequenceExpansionExpression__Alternatives)
+{ after(grammarAccess.getSequenceExpansionExpressionAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSelectOrRejectOperation
+entryRuleSelectOrRejectOperation
+:
+{ before(grammarAccess.getSelectOrRejectOperationRule()); }
+ ruleSelectOrRejectOperation
+{ after(grammarAccess.getSelectOrRejectOperationRule()); }
+ EOF
+;
+
+// Rule SelectOrRejectOperation
+ruleSelectOrRejectOperation
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getGroup()); }
+(rule__SelectOrRejectOperation__Group__0)
+{ after(grammarAccess.getSelectOrRejectOperationAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleCollectOrIterateOperation
+entryRuleCollectOrIterateOperation
+:
+{ before(grammarAccess.getCollectOrIterateOperationRule()); }
+ ruleCollectOrIterateOperation
+{ after(grammarAccess.getCollectOrIterateOperationRule()); }
+ EOF
+;
+
+// Rule CollectOrIterateOperation
+ruleCollectOrIterateOperation
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getGroup()); }
+(rule__CollectOrIterateOperation__Group__0)
+{ after(grammarAccess.getCollectOrIterateOperationAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleForAllOrExistsOrOneOperation
+entryRuleForAllOrExistsOrOneOperation
+:
+{ before(grammarAccess.getForAllOrExistsOrOneOperationRule()); }
+ ruleForAllOrExistsOrOneOperation
+{ after(grammarAccess.getForAllOrExistsOrOneOperationRule()); }
+ EOF
+;
+
+// Rule ForAllOrExistsOrOneOperation
+ruleForAllOrExistsOrOneOperation
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getGroup()); }
+(rule__ForAllOrExistsOrOneOperation__Group__0)
+{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleIsUniqueOperation
+entryRuleIsUniqueOperation
+:
+{ before(grammarAccess.getIsUniqueOperationRule()); }
+ ruleIsUniqueOperation
+{ after(grammarAccess.getIsUniqueOperationRule()); }
+ EOF
+;
+
+// Rule IsUniqueOperation
+ruleIsUniqueOperation
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getGroup()); }
+(rule__IsUniqueOperation__Group__0)
+{ after(grammarAccess.getIsUniqueOperationAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleValueSpecification
+entryRuleValueSpecification
+:
+{ before(grammarAccess.getValueSpecificationRule()); }
+ ruleValueSpecification
+{ after(grammarAccess.getValueSpecificationRule()); }
+ EOF
+;
+
+// Rule ValueSpecification
+ruleValueSpecification
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getValueSpecificationAccess().getAlternatives()); }
+(rule__ValueSpecification__Alternatives)
+{ after(grammarAccess.getValueSpecificationAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNonLiteralValueSpecification
+entryRuleNonLiteralValueSpecification
+:
+{ before(grammarAccess.getNonLiteralValueSpecificationRule()); }
+ ruleNonLiteralValueSpecification
+{ after(grammarAccess.getNonLiteralValueSpecificationRule()); }
+ EOF
+;
+
+// Rule NonLiteralValueSpecification
+ruleNonLiteralValueSpecification
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getNonLiteralValueSpecificationAccess().getAlternatives()); }
+(rule__NonLiteralValueSpecification__Alternatives)
+{ after(grammarAccess.getNonLiteralValueSpecificationAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleParenthesizedExpression
+entryRuleParenthesizedExpression
+:
+{ before(grammarAccess.getParenthesizedExpressionRule()); }
+ ruleParenthesizedExpression
+{ after(grammarAccess.getParenthesizedExpressionRule()); }
+ EOF
+;
+
+// Rule ParenthesizedExpression
+ruleParenthesizedExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getGroup()); }
+(rule__ParenthesizedExpression__Group__0)
+{ after(grammarAccess.getParenthesizedExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNullExpression
+entryRuleNullExpression
+:
+{ before(grammarAccess.getNullExpressionRule()); }
+ ruleNullExpression
+{ after(grammarAccess.getNullExpressionRule()); }
+ EOF
+;
+
+// Rule NullExpression
+ruleNullExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getNullExpressionAccess().getGroup()); }
+(rule__NullExpression__Group__0)
+{ after(grammarAccess.getNullExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleThisExpression
+entryRuleThisExpression
+:
+{ before(grammarAccess.getThisExpressionRule()); }
+ ruleThisExpression
+{ after(grammarAccess.getThisExpressionRule()); }
+ EOF
+;
+
+// Rule ThisExpression
+ruleThisExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getThisExpressionAccess().getGroup()); }
+(rule__ThisExpression__Group__0)
+{ after(grammarAccess.getThisExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSuperInvocationExpression
+entryRuleSuperInvocationExpression
+:
+{ before(grammarAccess.getSuperInvocationExpressionRule()); }
+ ruleSuperInvocationExpression
+{ after(grammarAccess.getSuperInvocationExpressionRule()); }
+ EOF
+;
+
+// Rule SuperInvocationExpression
+ruleSuperInvocationExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getGroup()); }
+(rule__SuperInvocationExpression__Group__0)
+{ after(grammarAccess.getSuperInvocationExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleInstanceCreationExpression
+entryRuleInstanceCreationExpression
+:
+{ before(grammarAccess.getInstanceCreationExpressionRule()); }
+ ruleInstanceCreationExpression
+{ after(grammarAccess.getInstanceCreationExpressionRule()); }
+ EOF
+;
+
+// Rule InstanceCreationExpression
+ruleInstanceCreationExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getInstanceCreationExpressionAccess().getGroup()); }
+(rule__InstanceCreationExpression__Group__0)
+{ after(grammarAccess.getInstanceCreationExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleInstanceCreationTuple
+entryRuleInstanceCreationTuple
+:
+{ before(grammarAccess.getInstanceCreationTupleRule()); }
+ ruleInstanceCreationTuple
+{ after(grammarAccess.getInstanceCreationTupleRule()); }
+ EOF
+;
+
+// Rule InstanceCreationTuple
+ruleInstanceCreationTuple
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getGroup()); }
+(rule__InstanceCreationTuple__Group__0)
+{ after(grammarAccess.getInstanceCreationTupleAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleInstanceCreationTupleElement
+entryRuleInstanceCreationTupleElement
+:
+{ before(grammarAccess.getInstanceCreationTupleElementRule()); }
+ ruleInstanceCreationTupleElement
+{ after(grammarAccess.getInstanceCreationTupleElementRule()); }
+ EOF
+;
+
+// Rule InstanceCreationTupleElement
+ruleInstanceCreationTupleElement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getInstanceCreationTupleElementAccess().getGroup()); }
+(rule__InstanceCreationTupleElement__Group__0)
+{ after(grammarAccess.getInstanceCreationTupleElementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSequenceConstructionOrAccessCompletion
+entryRuleSequenceConstructionOrAccessCompletion
+:
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionRule()); }
+ ruleSequenceConstructionOrAccessCompletion
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionRule()); }
+ EOF
+;
+
+// Rule SequenceConstructionOrAccessCompletion
+ruleSequenceConstructionOrAccessCompletion
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAlternatives()); }
+(rule__SequenceConstructionOrAccessCompletion__Alternatives)
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAccessCompletion
+entryRuleAccessCompletion
+:
+{ before(grammarAccess.getAccessCompletionRule()); }
+ ruleAccessCompletion
+{ after(grammarAccess.getAccessCompletionRule()); }
+ EOF
+;
+
+// Rule AccessCompletion
+ruleAccessCompletion
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getAccessCompletionAccess().getGroup()); }
+(rule__AccessCompletion__Group__0)
+{ after(grammarAccess.getAccessCompletionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePartialSequenceConstructionCompletion
+entryRulePartialSequenceConstructionCompletion
+:
+{ before(grammarAccess.getPartialSequenceConstructionCompletionRule()); }
+ rulePartialSequenceConstructionCompletion
+{ after(grammarAccess.getPartialSequenceConstructionCompletionRule()); }
+ EOF
+;
+
+// Rule PartialSequenceConstructionCompletion
+rulePartialSequenceConstructionCompletion
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPartialSequenceConstructionCompletionAccess().getGroup()); }
+(rule__PartialSequenceConstructionCompletion__Group__0)
+{ after(grammarAccess.getPartialSequenceConstructionCompletionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSequenceConstructionExpression
+entryRuleSequenceConstructionExpression
+:
+{ before(grammarAccess.getSequenceConstructionExpressionRule()); }
+ ruleSequenceConstructionExpression
+{ after(grammarAccess.getSequenceConstructionExpressionRule()); }
+ EOF
+;
+
+// Rule SequenceConstructionExpression
+ruleSequenceConstructionExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getGroup()); }
+(rule__SequenceConstructionExpression__Group__0)
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSequenceElement
+entryRuleSequenceElement
+:
+{ before(grammarAccess.getSequenceElementRule()); }
+ ruleSequenceElement
+{ after(grammarAccess.getSequenceElementRule()); }
+ EOF
+;
+
+// Rule SequenceElement
+ruleSequenceElement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSequenceElementAccess().getAlternatives()); }
+(rule__SequenceElement__Alternatives)
+{ after(grammarAccess.getSequenceElementAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleClassExtentExpression
+entryRuleClassExtentExpression
+:
+{ before(grammarAccess.getClassExtentExpressionRule()); }
+ ruleClassExtentExpression
+{ after(grammarAccess.getClassExtentExpressionRule()); }
+ EOF
+;
+
+// Rule ClassExtentExpression
+ruleClassExtentExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getClassExtentExpressionAccess().getGroup()); }
+(rule__ClassExtentExpression__Group__0)
+{ after(grammarAccess.getClassExtentExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleBlock
+entryRuleBlock
+:
+{ before(grammarAccess.getBlockRule()); }
+ ruleBlock
+{ after(grammarAccess.getBlockRule()); }
+ EOF
+;
+
+// Rule Block
+ruleBlock
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getBlockAccess().getGroup()); }
+(rule__Block__Group__0)
+{ after(grammarAccess.getBlockAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleStatementSequence
+entryRuleStatementSequence
+:
+{ before(grammarAccess.getStatementSequenceRule()); }
+ ruleStatementSequence
+{ after(grammarAccess.getStatementSequenceRule()); }
+ EOF
+;
+
+// Rule StatementSequence
+ruleStatementSequence
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+(
+{ before(grammarAccess.getStatementSequenceAccess().getStatementsAssignment()); }
+(rule__StatementSequence__StatementsAssignment)
+{ after(grammarAccess.getStatementSequenceAccess().getStatementsAssignment()); }
+)
+(
+{ before(grammarAccess.getStatementSequenceAccess().getStatementsAssignment()); }
+(rule__StatementSequence__StatementsAssignment)*
+{ after(grammarAccess.getStatementSequenceAccess().getStatementsAssignment()); }
+)
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleDocumentedStatement
+entryRuleDocumentedStatement
+:
+{ before(grammarAccess.getDocumentedStatementRule()); }
+ ruleDocumentedStatement
+{ after(grammarAccess.getDocumentedStatementRule()); }
+ EOF
+;
+
+// Rule DocumentedStatement
+ruleDocumentedStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getDocumentedStatementAccess().getGroup()); }
+(rule__DocumentedStatement__Group__0)
+{ after(grammarAccess.getDocumentedStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleInlineStatement
+entryRuleInlineStatement
+:
+{ before(grammarAccess.getInlineStatementRule()); }
+ ruleInlineStatement
+{ after(grammarAccess.getInlineStatementRule()); }
+ EOF
+;
+
+// Rule InlineStatement
+ruleInlineStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getInlineStatementAccess().getGroup()); }
+(rule__InlineStatement__Group__0)
+{ after(grammarAccess.getInlineStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAnnotatedStatement
+entryRuleAnnotatedStatement
+:
+{ before(grammarAccess.getAnnotatedStatementRule()); }
+ ruleAnnotatedStatement
+{ after(grammarAccess.getAnnotatedStatementRule()); }
+ EOF
+;
+
+// Rule AnnotatedStatement
+ruleAnnotatedStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getAnnotatedStatementAccess().getGroup()); }
+(rule__AnnotatedStatement__Group__0)
+{ after(grammarAccess.getAnnotatedStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleStatement
+entryRuleStatement
+:
+{ before(grammarAccess.getStatementRule()); }
+ ruleStatement
+{ after(grammarAccess.getStatementRule()); }
+ EOF
+;
+
+// Rule Statement
+ruleStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getStatementAccess().getAlternatives()); }
+(rule__Statement__Alternatives)
+{ after(grammarAccess.getStatementAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAnnotation
+entryRuleAnnotation
+:
+{ before(grammarAccess.getAnnotationRule()); }
+ ruleAnnotation
+{ after(grammarAccess.getAnnotationRule()); }
+ EOF
+;
+
+// Rule Annotation
+ruleAnnotation
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getAnnotationAccess().getGroup()); }
+(rule__Annotation__Group__0)
+{ after(grammarAccess.getAnnotationAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleBlockStatement
+entryRuleBlockStatement
+:
+{ before(grammarAccess.getBlockStatementRule()); }
+ ruleBlockStatement
+{ after(grammarAccess.getBlockStatementRule()); }
+ EOF
+;
+
+// Rule BlockStatement
+ruleBlockStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getBlockStatementAccess().getBlockAssignment()); }
+(rule__BlockStatement__BlockAssignment)
+{ after(grammarAccess.getBlockStatementAccess().getBlockAssignment()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleEmptyStatement
+entryRuleEmptyStatement
+:
+{ before(grammarAccess.getEmptyStatementRule()); }
+ ruleEmptyStatement
+{ after(grammarAccess.getEmptyStatementRule()); }
+ EOF
+;
+
+// Rule EmptyStatement
+ruleEmptyStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getEmptyStatementAccess().getGroup()); }
+(rule__EmptyStatement__Group__0)
+{ after(grammarAccess.getEmptyStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLocalNameDeclarationStatement
+entryRuleLocalNameDeclarationStatement
+:
+{ before(grammarAccess.getLocalNameDeclarationStatementRule()); }
+ ruleLocalNameDeclarationStatement
+{ after(grammarAccess.getLocalNameDeclarationStatementRule()); }
+ EOF
+;
+
+// Rule LocalNameDeclarationStatement
+ruleLocalNameDeclarationStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getGroup()); }
+(rule__LocalNameDeclarationStatement__Group__0)
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleIfStatement
+entryRuleIfStatement
+:
+{ before(grammarAccess.getIfStatementRule()); }
+ ruleIfStatement
+{ after(grammarAccess.getIfStatementRule()); }
+ EOF
+;
+
+// Rule IfStatement
+ruleIfStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getIfStatementAccess().getGroup()); }
+(rule__IfStatement__Group__0)
+{ after(grammarAccess.getIfStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSequentialClauses
+entryRuleSequentialClauses
+:
+{ before(grammarAccess.getSequentialClausesRule()); }
+ ruleSequentialClauses
+{ after(grammarAccess.getSequentialClausesRule()); }
+ EOF
+;
+
+// Rule SequentialClauses
+ruleSequentialClauses
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSequentialClausesAccess().getGroup()); }
+(rule__SequentialClauses__Group__0)
+{ after(grammarAccess.getSequentialClausesAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleConcurrentClauses
+entryRuleConcurrentClauses
+:
+{ before(grammarAccess.getConcurrentClausesRule()); }
+ ruleConcurrentClauses
+{ after(grammarAccess.getConcurrentClausesRule()); }
+ EOF
+;
+
+// Rule ConcurrentClauses
+ruleConcurrentClauses
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getConcurrentClausesAccess().getGroup()); }
+(rule__ConcurrentClauses__Group__0)
+{ after(grammarAccess.getConcurrentClausesAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNonFinalClause
+entryRuleNonFinalClause
+:
+{ before(grammarAccess.getNonFinalClauseRule()); }
+ ruleNonFinalClause
+{ after(grammarAccess.getNonFinalClauseRule()); }
+ EOF
+;
+
+// Rule NonFinalClause
+ruleNonFinalClause
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getNonFinalClauseAccess().getGroup()); }
+(rule__NonFinalClause__Group__0)
+{ after(grammarAccess.getNonFinalClauseAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleFinalClause
+entryRuleFinalClause
+:
+{ before(grammarAccess.getFinalClauseRule()); }
+ ruleFinalClause
+{ after(grammarAccess.getFinalClauseRule()); }
+ EOF
+;
+
+// Rule FinalClause
+ruleFinalClause
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getFinalClauseAccess().getGroup()); }
+(rule__FinalClause__Group__0)
+{ after(grammarAccess.getFinalClauseAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSwitchStatement
+entryRuleSwitchStatement
+:
+{ before(grammarAccess.getSwitchStatementRule()); }
+ ruleSwitchStatement
+{ after(grammarAccess.getSwitchStatementRule()); }
+ EOF
+;
+
+// Rule SwitchStatement
+ruleSwitchStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSwitchStatementAccess().getGroup()); }
+(rule__SwitchStatement__Group__0)
+{ after(grammarAccess.getSwitchStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSwitchClause
+entryRuleSwitchClause
+:
+{ before(grammarAccess.getSwitchClauseRule()); }
+ ruleSwitchClause
+{ after(grammarAccess.getSwitchClauseRule()); }
+ EOF
+;
+
+// Rule SwitchClause
+ruleSwitchClause
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSwitchClauseAccess().getGroup()); }
+(rule__SwitchClause__Group__0)
+{ after(grammarAccess.getSwitchClauseAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSwitchCase
+entryRuleSwitchCase
+:
+{ before(grammarAccess.getSwitchCaseRule()); }
+ ruleSwitchCase
+{ after(grammarAccess.getSwitchCaseRule()); }
+ EOF
+;
+
+// Rule SwitchCase
+ruleSwitchCase
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSwitchCaseAccess().getGroup()); }
+(rule__SwitchCase__Group__0)
+{ after(grammarAccess.getSwitchCaseAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSwitchDefaultClause
+entryRuleSwitchDefaultClause
+:
+{ before(grammarAccess.getSwitchDefaultClauseRule()); }
+ ruleSwitchDefaultClause
+{ after(grammarAccess.getSwitchDefaultClauseRule()); }
+ EOF
+;
+
+// Rule SwitchDefaultClause
+ruleSwitchDefaultClause
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSwitchDefaultClauseAccess().getGroup()); }
+(rule__SwitchDefaultClause__Group__0)
+{ after(grammarAccess.getSwitchDefaultClauseAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNonEmptyStatementSequence
+entryRuleNonEmptyStatementSequence
+:
+{ before(grammarAccess.getNonEmptyStatementSequenceRule()); }
+ ruleNonEmptyStatementSequence
+{ after(grammarAccess.getNonEmptyStatementSequenceRule()); }
+ EOF
+;
+
+// Rule NonEmptyStatementSequence
+ruleNonEmptyStatementSequence
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+(
+{ before(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementAssignment()); }
+(rule__NonEmptyStatementSequence__StatementAssignment)
+{ after(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementAssignment()); }
+)
+(
+{ before(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementAssignment()); }
+(rule__NonEmptyStatementSequence__StatementAssignment)*
+{ after(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementAssignment()); }
+)
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleWhileStatement
+entryRuleWhileStatement
+:
+{ before(grammarAccess.getWhileStatementRule()); }
+ ruleWhileStatement
+{ after(grammarAccess.getWhileStatementRule()); }
+ EOF
+;
+
+// Rule WhileStatement
+ruleWhileStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getWhileStatementAccess().getGroup()); }
+(rule__WhileStatement__Group__0)
+{ after(grammarAccess.getWhileStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleDoStatement
+entryRuleDoStatement
+:
+{ before(grammarAccess.getDoStatementRule()); }
+ ruleDoStatement
+{ after(grammarAccess.getDoStatementRule()); }
+ EOF
+;
+
+// Rule DoStatement
+ruleDoStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getDoStatementAccess().getGroup()); }
+(rule__DoStatement__Group__0)
+{ after(grammarAccess.getDoStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleForStatement
+entryRuleForStatement
+:
+{ before(grammarAccess.getForStatementRule()); }
+ ruleForStatement
+{ after(grammarAccess.getForStatementRule()); }
+ EOF
+;
+
+// Rule ForStatement
+ruleForStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getForStatementAccess().getGroup()); }
+(rule__ForStatement__Group__0)
+{ after(grammarAccess.getForStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleForControl
+entryRuleForControl
+:
+{ before(grammarAccess.getForControlRule()); }
+ ruleForControl
+{ after(grammarAccess.getForControlRule()); }
+ EOF
+;
+
+// Rule ForControl
+ruleForControl
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getForControlAccess().getGroup()); }
+(rule__ForControl__Group__0)
+{ after(grammarAccess.getForControlAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLoopVariableDefinition
+entryRuleLoopVariableDefinition
+:
+{ before(grammarAccess.getLoopVariableDefinitionRule()); }
+ ruleLoopVariableDefinition
+{ after(grammarAccess.getLoopVariableDefinitionRule()); }
+ EOF
+;
+
+// Rule LoopVariableDefinition
+ruleLoopVariableDefinition
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getAlternatives()); }
+(rule__LoopVariableDefinition__Alternatives)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleBreakStatement
+entryRuleBreakStatement
+:
+{ before(grammarAccess.getBreakStatementRule()); }
+ ruleBreakStatement
+{ after(grammarAccess.getBreakStatementRule()); }
+ EOF
+;
+
+// Rule BreakStatement
+ruleBreakStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getBreakStatementAccess().getGroup()); }
+(rule__BreakStatement__Group__0)
+{ after(grammarAccess.getBreakStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleReturnStatement
+entryRuleReturnStatement
+:
+{ before(grammarAccess.getReturnStatementRule()); }
+ ruleReturnStatement
+{ after(grammarAccess.getReturnStatementRule()); }
+ EOF
+;
+
+// Rule ReturnStatement
+ruleReturnStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getReturnStatementAccess().getGroup()); }
+(rule__ReturnStatement__Group__0)
+{ after(grammarAccess.getReturnStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAcceptStatement
+entryRuleAcceptStatement
+:
+{ before(grammarAccess.getAcceptStatementRule()); }
+ ruleAcceptStatement
+{ after(grammarAccess.getAcceptStatementRule()); }
+ EOF
+;
+
+// Rule AcceptStatement
+ruleAcceptStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getAcceptStatementAccess().getGroup()); }
+(rule__AcceptStatement__Group__0)
+{ after(grammarAccess.getAcceptStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSimpleAcceptStatementCompletion
+entryRuleSimpleAcceptStatementCompletion
+:
+{ before(grammarAccess.getSimpleAcceptStatementCompletionRule()); }
+ ruleSimpleAcceptStatementCompletion
+{ after(grammarAccess.getSimpleAcceptStatementCompletionRule()); }
+ EOF
+;
+
+// Rule SimpleAcceptStatementCompletion
+ruleSimpleAcceptStatementCompletion
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSimpleAcceptStatementCompletionAccess().getGroup()); }
+(rule__SimpleAcceptStatementCompletion__Group__0)
+{ after(grammarAccess.getSimpleAcceptStatementCompletionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleCompoundAcceptStatementCompletion
+entryRuleCompoundAcceptStatementCompletion
+:
+{ before(grammarAccess.getCompoundAcceptStatementCompletionRule()); }
+ ruleCompoundAcceptStatementCompletion
+{ after(grammarAccess.getCompoundAcceptStatementCompletionRule()); }
+ EOF
+;
+
+// Rule CompoundAcceptStatementCompletion
+ruleCompoundAcceptStatementCompletion
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getGroup()); }
+(rule__CompoundAcceptStatementCompletion__Group__0)
+{ after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAcceptBlock
+entryRuleAcceptBlock
+:
+{ before(grammarAccess.getAcceptBlockRule()); }
+ ruleAcceptBlock
+{ after(grammarAccess.getAcceptBlockRule()); }
+ EOF
+;
+
+// Rule AcceptBlock
+ruleAcceptBlock
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getAcceptBlockAccess().getGroup()); }
+(rule__AcceptBlock__Group__0)
+{ after(grammarAccess.getAcceptBlockAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAcceptClause
+entryRuleAcceptClause
+:
+{ before(grammarAccess.getAcceptClauseRule()); }
+ ruleAcceptClause
+{ after(grammarAccess.getAcceptClauseRule()); }
+ EOF
+;
+
+// Rule AcceptClause
+ruleAcceptClause
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getAcceptClauseAccess().getGroup()); }
+(rule__AcceptClause__Group__0)
+{ after(grammarAccess.getAcceptClauseAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleClassifyStatement
+entryRuleClassifyStatement
+:
+{ before(grammarAccess.getClassifyStatementRule()); }
+ ruleClassifyStatement
+{ after(grammarAccess.getClassifyStatementRule()); }
+ EOF
+;
+
+// Rule ClassifyStatement
+ruleClassifyStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getClassifyStatementAccess().getGroup()); }
+(rule__ClassifyStatement__Group__0)
+{ after(grammarAccess.getClassifyStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleClassificationClause
+entryRuleClassificationClause
+:
+{ before(grammarAccess.getClassificationClauseRule()); }
+ ruleClassificationClause
+{ after(grammarAccess.getClassificationClauseRule()); }
+ EOF
+;
+
+// Rule ClassificationClause
+ruleClassificationClause
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getClassificationClauseAccess().getAlternatives()); }
+(rule__ClassificationClause__Alternatives)
+{ after(grammarAccess.getClassificationClauseAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleClassificationFromClause
+entryRuleClassificationFromClause
+:
+{ before(grammarAccess.getClassificationFromClauseRule()); }
+ ruleClassificationFromClause
+{ after(grammarAccess.getClassificationFromClauseRule()); }
+ EOF
+;
+
+// Rule ClassificationFromClause
+ruleClassificationFromClause
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getClassificationFromClauseAccess().getGroup()); }
+(rule__ClassificationFromClause__Group__0)
+{ after(grammarAccess.getClassificationFromClauseAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleClassificationToClause
+entryRuleClassificationToClause
+:
+{ before(grammarAccess.getClassificationToClauseRule()); }
+ ruleClassificationToClause
+{ after(grammarAccess.getClassificationToClauseRule()); }
+ EOF
+;
+
+// Rule ClassificationToClause
+ruleClassificationToClause
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getClassificationToClauseAccess().getGroup()); }
+(rule__ClassificationToClause__Group__0)
+{ after(grammarAccess.getClassificationToClauseAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleReclassifyAllClause
+entryRuleReclassifyAllClause
+:
+{ before(grammarAccess.getReclassifyAllClauseRule()); }
+ ruleReclassifyAllClause
+{ after(grammarAccess.getReclassifyAllClauseRule()); }
+ EOF
+;
+
+// Rule ReclassifyAllClause
+ruleReclassifyAllClause
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getReclassifyAllClauseAccess().getGroup()); }
+(rule__ReclassifyAllClause__Group__0)
+{ after(grammarAccess.getReclassifyAllClauseAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleQualifiedNameList
+entryRuleQualifiedNameList
+:
+{ before(grammarAccess.getQualifiedNameListRule()); }
+ ruleQualifiedNameList
+{ after(grammarAccess.getQualifiedNameListRule()); }
+ EOF
+;
+
+// Rule QualifiedNameList
+ruleQualifiedNameList
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getQualifiedNameListAccess().getGroup()); }
+(rule__QualifiedNameList__Group__0)
+{ after(grammarAccess.getQualifiedNameListAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleInvocationOrAssignementOrDeclarationStatement
+entryRuleInvocationOrAssignementOrDeclarationStatement
+:
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementRule()); }
+ ruleInvocationOrAssignementOrDeclarationStatement
+{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementRule()); }
+ EOF
+;
+
+// Rule InvocationOrAssignementOrDeclarationStatement
+ruleInvocationOrAssignementOrDeclarationStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getGroup()); }
+(rule__InvocationOrAssignementOrDeclarationStatement__Group__0)
+{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSuperInvocationStatement
+entryRuleSuperInvocationStatement
+:
+{ before(grammarAccess.getSuperInvocationStatementRule()); }
+ ruleSuperInvocationStatement
+{ after(grammarAccess.getSuperInvocationStatementRule()); }
+ EOF
+;
+
+// Rule SuperInvocationStatement
+ruleSuperInvocationStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSuperInvocationStatementAccess().getGroup()); }
+(rule__SuperInvocationStatement__Group__0)
+{ after(grammarAccess.getSuperInvocationStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleThisInvocationStatement
+entryRuleThisInvocationStatement
+:
+{ before(grammarAccess.getThisInvocationStatementRule()); }
+ ruleThisInvocationStatement
+{ after(grammarAccess.getThisInvocationStatementRule()); }
+ EOF
+;
+
+// Rule ThisInvocationStatement
+ruleThisInvocationStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getThisInvocationStatementAccess().getGroup()); }
+(rule__ThisInvocationStatement__Group__0)
+{ after(grammarAccess.getThisInvocationStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleInstanceCreationInvocationStatement
+entryRuleInstanceCreationInvocationStatement
+:
+{ before(grammarAccess.getInstanceCreationInvocationStatementRule()); }
+ ruleInstanceCreationInvocationStatement
+{ after(grammarAccess.getInstanceCreationInvocationStatementRule()); }
+ EOF
+;
+
+// Rule InstanceCreationInvocationStatement
+ruleInstanceCreationInvocationStatement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getInstanceCreationInvocationStatementAccess().getGroup()); }
+(rule__InstanceCreationInvocationStatement__Group__0)
+{ after(grammarAccess.getInstanceCreationInvocationStatementAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleVariableDeclarationCompletion
+entryRuleVariableDeclarationCompletion
+:
+{ before(grammarAccess.getVariableDeclarationCompletionRule()); }
+ ruleVariableDeclarationCompletion
+{ after(grammarAccess.getVariableDeclarationCompletionRule()); }
+ EOF
+;
+
+// Rule VariableDeclarationCompletion
+ruleVariableDeclarationCompletion
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getVariableDeclarationCompletionAccess().getGroup()); }
+(rule__VariableDeclarationCompletion__Group__0)
+{ after(grammarAccess.getVariableDeclarationCompletionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAssignmentCompletion
+entryRuleAssignmentCompletion
+:
+{ before(grammarAccess.getAssignmentCompletionRule()); }
+ ruleAssignmentCompletion
+{ after(grammarAccess.getAssignmentCompletionRule()); }
+ EOF
+;
+
+// Rule AssignmentCompletion
+ruleAssignmentCompletion
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getAssignmentCompletionAccess().getGroup()); }
+(rule__AssignmentCompletion__Group__0)
+{ after(grammarAccess.getAssignmentCompletionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+// Rule BooleanValue
+ruleBooleanValue
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBooleanValueAccess().getAlternatives()); }
+(rule__BooleanValue__Alternatives)
+{ after(grammarAccess.getBooleanValueAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Rule LinkOperationKind
+ruleLinkOperationKind
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationKindAccess().getAlternatives()); }
+(rule__LinkOperationKind__Alternatives)
+{ after(grammarAccess.getLinkOperationKindAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Rule SelectOrRejectOperator
+ruleSelectOrRejectOperator
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperatorAccess().getAlternatives()); }
+(rule__SelectOrRejectOperator__Alternatives)
+{ after(grammarAccess.getSelectOrRejectOperatorAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Rule CollectOrIterateOperator
+ruleCollectOrIterateOperator
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperatorAccess().getAlternatives()); }
+(rule__CollectOrIterateOperator__Alternatives)
+{ after(grammarAccess.getCollectOrIterateOperatorAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Rule ForAllOrExistsOrOneOperator
+ruleForAllOrExistsOrOneOperator
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getAlternatives()); }
+(rule__ForAllOrExistsOrOneOperator__Alternatives)
+{ after(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Rule AnnotationKind
+ruleAnnotationKind
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotationKindAccess().getAlternatives()); }
+(rule__AnnotationKind__Alternatives)
+{ after(grammarAccess.getAnnotationKindAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Rule AssignmentOperator
+ruleAssignmentOperator
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignmentOperatorAccess().getAlternatives()); }
+(rule__AssignmentOperator__Alternatives)
+{ after(grammarAccess.getAssignmentOperatorAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+rule__LITERAL__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLITERALAccess().getBOOLEAN_LITERALParserRuleCall_0()); }
+ ruleBOOLEAN_LITERAL
+{ after(grammarAccess.getLITERALAccess().getBOOLEAN_LITERALParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getLITERALAccess().getNUMBER_LITERALParserRuleCall_1()); }
+ ruleNUMBER_LITERAL
+{ after(grammarAccess.getLITERALAccess().getNUMBER_LITERALParserRuleCall_1()); }
+)
+
+ |(
+{ before(grammarAccess.getLITERALAccess().getSTRING_LITERALParserRuleCall_2()); }
+ ruleSTRING_LITERAL
+{ after(grammarAccess.getLITERALAccess().getSTRING_LITERALParserRuleCall_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NUMBER_LITERAL__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNUMBER_LITERALAccess().getINTEGER_LITERALParserRuleCall_0()); }
+ ruleINTEGER_LITERAL
+{ after(grammarAccess.getNUMBER_LITERALAccess().getINTEGER_LITERALParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getNUMBER_LITERALAccess().getUNLIMITED_LITERALParserRuleCall_1()); }
+ ruleUNLIMITED_LITERAL
+{ after(grammarAccess.getNUMBER_LITERALAccess().getUNLIMITED_LITERALParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Alternatives_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getGroup_0_0()); }
+(rule__NameExpression__Group_0_0__0)
+{ after(grammarAccess.getNameExpressionAccess().getGroup_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getNameExpressionAccess().getGroup_0_1()); }
+(rule__NameExpression__Group_0_1__0)
+{ after(grammarAccess.getNameExpressionAccess().getGroup_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__PrefixOpAlternatives_0_0_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPrefixOpPlusSignPlusSignKeyword_0_0_0_0_0()); }
+
+ '++'
+
+{ after(grammarAccess.getNameExpressionAccess().getPrefixOpPlusSignPlusSignKeyword_0_0_0_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getNameExpressionAccess().getPrefixOpHyphenMinusHyphenMinusKeyword_0_0_0_0_1()); }
+
+ '--'
+
+{ after(grammarAccess.getNameExpressionAccess().getPrefixOpHyphenMinusHyphenMinusKeyword_0_0_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Alternatives_0_1_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getInvocationCompletionAssignment_0_1_2_0()); }
+(rule__NameExpression__InvocationCompletionAssignment_0_1_2_0)
+{ after(grammarAccess.getNameExpressionAccess().getInvocationCompletionAssignment_0_1_2_0()); }
+)
+
+ |(
+{ before(grammarAccess.getNameExpressionAccess().getSequenceConstructionCompletionAssignment_0_1_2_1()); }
+(rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1)
+{ after(grammarAccess.getNameExpressionAccess().getSequenceConstructionCompletionAssignment_0_1_2_1()); }
+)
+
+ |(
+{ before(grammarAccess.getNameExpressionAccess().getPostfixOpAssignment_0_1_2_2()); }
+(rule__NameExpression__PostfixOpAssignment_0_1_2_2)
+{ after(grammarAccess.getNameExpressionAccess().getPostfixOpAssignment_0_1_2_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPostfixOpPlusSignPlusSignKeyword_0_1_2_2_0_0()); }
+
+ '++'
+
+{ after(grammarAccess.getNameExpressionAccess().getPostfixOpPlusSignPlusSignKeyword_0_1_2_2_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getNameExpressionAccess().getPostfixOpHyphenMinusHyphenMinusKeyword_0_1_2_2_0_1()); }
+
+ '--'
+
+{ after(grammarAccess.getNameExpressionAccess().getPostfixOpHyphenMinusHyphenMinusKeyword_0_1_2_2_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__EqualityExpression__OpAlternatives_1_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getOpEqualsSignEqualsSignKeyword_1_0_0_0()); }
+
+ '=='
+
+{ after(grammarAccess.getEqualityExpressionAccess().getOpEqualsSignEqualsSignKeyword_1_0_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getEqualityExpressionAccess().getOpExclamationMarkEqualsSignKeyword_1_0_0_1()); }
+
+ '!='
+
+{ after(grammarAccess.getEqualityExpressionAccess().getOpExclamationMarkEqualsSignKeyword_1_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationExpression__OpAlternatives_1_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getOpInstanceofKeyword_1_0_0_0()); }
+
+ 'instanceof'
+
+{ after(grammarAccess.getClassificationExpressionAccess().getOpInstanceofKeyword_1_0_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getClassificationExpressionAccess().getOpHastypeKeyword_1_0_0_1()); }
+
+ 'hastype'
+
+{ after(grammarAccess.getClassificationExpressionAccess().getOpHastypeKeyword_1_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RelationalExpression__OpAlternatives_1_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRelationalExpressionAccess().getOpLessThanSignKeyword_1_0_0_0()); }
+
+ '<'
+
+{ after(grammarAccess.getRelationalExpressionAccess().getOpLessThanSignKeyword_1_0_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getRelationalExpressionAccess().getOpGreaterThanSignKeyword_1_0_0_1()); }
+
+ '>'
+
+{ after(grammarAccess.getRelationalExpressionAccess().getOpGreaterThanSignKeyword_1_0_0_1()); }
+)
+
+ |(
+{ before(grammarAccess.getRelationalExpressionAccess().getOpLessThanSignEqualsSignKeyword_1_0_0_2()); }
+
+ '<='
+
+{ after(grammarAccess.getRelationalExpressionAccess().getOpLessThanSignEqualsSignKeyword_1_0_0_2()); }
+)
+
+ |(
+{ before(grammarAccess.getRelationalExpressionAccess().getOpGreaterThanSignEqualsSignKeyword_1_0_0_3()); }
+
+ '>='
+
+{ after(grammarAccess.getRelationalExpressionAccess().getOpGreaterThanSignEqualsSignKeyword_1_0_0_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ShiftExpression__OpAlternatives_1_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getShiftExpressionAccess().getOpLessThanSignLessThanSignKeyword_1_0_0_0()); }
+
+ '<<'
+
+{ after(grammarAccess.getShiftExpressionAccess().getOpLessThanSignLessThanSignKeyword_1_0_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getShiftExpressionAccess().getOpGreaterThanSignGreaterThanSignKeyword_1_0_0_1()); }
+
+ '>>'
+
+{ after(grammarAccess.getShiftExpressionAccess().getOpGreaterThanSignGreaterThanSignKeyword_1_0_0_1()); }
+)
+
+ |(
+{ before(grammarAccess.getShiftExpressionAccess().getOpGreaterThanSignGreaterThanSignGreaterThanSignKeyword_1_0_0_2()); }
+
+ '>>>'
+
+{ after(grammarAccess.getShiftExpressionAccess().getOpGreaterThanSignGreaterThanSignGreaterThanSignKeyword_1_0_0_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AdditiveExpression__OpAlternatives_1_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAdditiveExpressionAccess().getOpPlusSignKeyword_1_0_0_0()); }
+
+ '+'
+
+{ after(grammarAccess.getAdditiveExpressionAccess().getOpPlusSignKeyword_1_0_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getAdditiveExpressionAccess().getOpHyphenMinusKeyword_1_0_0_1()); }
+
+ '-'
+
+{ after(grammarAccess.getAdditiveExpressionAccess().getOpHyphenMinusKeyword_1_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__MultiplicativeExpression__OpAlternatives_1_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getOpAsteriskKeyword_1_0_0_0()); }
+
+ '*'
+
+{ after(grammarAccess.getMultiplicativeExpressionAccess().getOpAsteriskKeyword_1_0_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getOpSolidusKeyword_1_0_0_1()); }
+
+ '/'
+
+{ after(grammarAccess.getMultiplicativeExpressionAccess().getOpSolidusKeyword_1_0_0_1()); }
+)
+
+ |(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getOpPercentSignKeyword_1_0_0_2()); }
+
+ '%'
+
+{ after(grammarAccess.getMultiplicativeExpressionAccess().getOpPercentSignKeyword_1_0_0_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__UnaryExpression__OpAlternatives_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getUnaryExpressionAccess().getOpExclamationMarkKeyword_0_0_0()); }
+
+ '!'
+
+{ after(grammarAccess.getUnaryExpressionAccess().getOpExclamationMarkKeyword_0_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getUnaryExpressionAccess().getOpHyphenMinusKeyword_0_0_1()); }
+
+ '-'
+
+{ after(grammarAccess.getUnaryExpressionAccess().getOpHyphenMinusKeyword_0_0_1()); }
+)
+
+ |(
+{ before(grammarAccess.getUnaryExpressionAccess().getOpPlusSignKeyword_0_0_2()); }
+
+ '+'
+
+{ after(grammarAccess.getUnaryExpressionAccess().getOpPlusSignKeyword_0_0_2()); }
+)
+
+ |(
+{ before(grammarAccess.getUnaryExpressionAccess().getOpDollarSignKeyword_0_0_3()); }
+
+ '$'
+
+{ after(grammarAccess.getUnaryExpressionAccess().getOpDollarSignKeyword_0_0_3()); }
+)
+
+ |(
+{ before(grammarAccess.getUnaryExpressionAccess().getOpTildeKeyword_0_0_4()); }
+
+ '~'
+
+{ after(grammarAccess.getUnaryExpressionAccess().getOpTildeKeyword_0_0_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SuffixExpression__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSuffixExpressionAccess().getOperationCallExpressionParserRuleCall_0()); }
+ ruleOperationCallExpression
+{ after(grammarAccess.getSuffixExpressionAccess().getOperationCallExpressionParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getSuffixExpressionAccess().getPropertyCallExpressionParserRuleCall_1()); }
+ rulePropertyCallExpression
+{ after(grammarAccess.getSuffixExpressionAccess().getPropertyCallExpressionParserRuleCall_1()); }
+)
+
+ |(
+{ before(grammarAccess.getSuffixExpressionAccess().getLinkOperationExpressionParserRuleCall_2()); }
+ ruleLinkOperationExpression
+{ after(grammarAccess.getSuffixExpressionAccess().getLinkOperationExpressionParserRuleCall_2()); }
+)
+
+ |(
+{ before(grammarAccess.getSuffixExpressionAccess().getSequenceOperationExpressionParserRuleCall_3()); }
+ ruleSequenceOperationExpression
+{ after(grammarAccess.getSuffixExpressionAccess().getSequenceOperationExpressionParserRuleCall_3()); }
+)
+
+ |(
+{ before(grammarAccess.getSuffixExpressionAccess().getSequenceReductionExpressionParserRuleCall_4()); }
+ ruleSequenceReductionExpression
+{ after(grammarAccess.getSuffixExpressionAccess().getSequenceReductionExpressionParserRuleCall_4()); }
+)
+
+ |(
+{ before(grammarAccess.getSuffixExpressionAccess().getSequenceExpansionExpressionParserRuleCall_5()); }
+ ruleSequenceExpansionExpression
+{ after(grammarAccess.getSuffixExpressionAccess().getSequenceExpansionExpressionParserRuleCall_5()); }
+)
+
+ |(
+{ before(grammarAccess.getSuffixExpressionAccess().getClassExtentExpressionParserRuleCall_6()); }
+ ruleClassExtentExpression
+{ after(grammarAccess.getSuffixExpressionAccess().getClassExtentExpressionParserRuleCall_6()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceExpansionExpression__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceExpansionExpressionAccess().getSelectOrRejectOperationParserRuleCall_0()); }
+ ruleSelectOrRejectOperation
+{ after(grammarAccess.getSequenceExpansionExpressionAccess().getSelectOrRejectOperationParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getSequenceExpansionExpressionAccess().getCollectOrIterateOperationParserRuleCall_1()); }
+ ruleCollectOrIterateOperation
+{ after(grammarAccess.getSequenceExpansionExpressionAccess().getCollectOrIterateOperationParserRuleCall_1()); }
+)
+
+ |(
+{ before(grammarAccess.getSequenceExpansionExpressionAccess().getForAllOrExistsOrOneOperationParserRuleCall_2()); }
+ ruleForAllOrExistsOrOneOperation
+{ after(grammarAccess.getSequenceExpansionExpressionAccess().getForAllOrExistsOrOneOperationParserRuleCall_2()); }
+)
+
+ |(
+{ before(grammarAccess.getSequenceExpansionExpressionAccess().getIsUniqueOperationParserRuleCall_3()); }
+ ruleIsUniqueOperation
+{ after(grammarAccess.getSequenceExpansionExpressionAccess().getIsUniqueOperationParserRuleCall_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ValueSpecification__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getValueSpecificationAccess().getNameExpressionParserRuleCall_0()); }
+ ruleNameExpression
+{ after(grammarAccess.getValueSpecificationAccess().getNameExpressionParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getValueSpecificationAccess().getLITERALParserRuleCall_1()); }
+ ruleLITERAL
+{ after(grammarAccess.getValueSpecificationAccess().getLITERALParserRuleCall_1()); }
+)
+
+ |(
+{ before(grammarAccess.getValueSpecificationAccess().getThisExpressionParserRuleCall_2()); }
+ ruleThisExpression
+{ after(grammarAccess.getValueSpecificationAccess().getThisExpressionParserRuleCall_2()); }
+)
+
+ |(
+{ before(grammarAccess.getValueSpecificationAccess().getSuperInvocationExpressionParserRuleCall_3()); }
+ ruleSuperInvocationExpression
+{ after(grammarAccess.getValueSpecificationAccess().getSuperInvocationExpressionParserRuleCall_3()); }
+)
+
+ |(
+{ before(grammarAccess.getValueSpecificationAccess().getInstanceCreationExpressionParserRuleCall_4()); }
+ ruleInstanceCreationExpression
+{ after(grammarAccess.getValueSpecificationAccess().getInstanceCreationExpressionParserRuleCall_4()); }
+)
+
+ |(
+{ before(grammarAccess.getValueSpecificationAccess().getParenthesizedExpressionParserRuleCall_5()); }
+ ruleParenthesizedExpression
+{ after(grammarAccess.getValueSpecificationAccess().getParenthesizedExpressionParserRuleCall_5()); }
+)
+
+ |(
+{ before(grammarAccess.getValueSpecificationAccess().getNullExpressionParserRuleCall_6()); }
+ ruleNullExpression
+{ after(grammarAccess.getValueSpecificationAccess().getNullExpressionParserRuleCall_6()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NonLiteralValueSpecification__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNonLiteralValueSpecificationAccess().getNameExpressionParserRuleCall_0()); }
+ ruleNameExpression
+{ after(grammarAccess.getNonLiteralValueSpecificationAccess().getNameExpressionParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getNonLiteralValueSpecificationAccess().getParenthesizedExpressionParserRuleCall_1()); }
+ ruleParenthesizedExpression
+{ after(grammarAccess.getNonLiteralValueSpecificationAccess().getParenthesizedExpressionParserRuleCall_1()); }
+)
+
+ |(
+{ before(grammarAccess.getNonLiteralValueSpecificationAccess().getInstanceCreationExpressionParserRuleCall_2()); }
+ ruleInstanceCreationExpression
+{ after(grammarAccess.getNonLiteralValueSpecificationAccess().getInstanceCreationExpressionParserRuleCall_2()); }
+)
+
+ |(
+{ before(grammarAccess.getNonLiteralValueSpecificationAccess().getThisExpressionParserRuleCall_3()); }
+ ruleThisExpression
+{ after(grammarAccess.getNonLiteralValueSpecificationAccess().getThisExpressionParserRuleCall_3()); }
+)
+
+ |(
+{ before(grammarAccess.getNonLiteralValueSpecificationAccess().getSuperInvocationExpressionParserRuleCall_4()); }
+ ruleSuperInvocationExpression
+{ after(grammarAccess.getNonLiteralValueSpecificationAccess().getSuperInvocationExpressionParserRuleCall_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ParenthesizedExpression__Alternatives_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getCastedAssignment_3_0()); }
+(rule__ParenthesizedExpression__CastedAssignment_3_0)
+{ after(grammarAccess.getParenthesizedExpressionAccess().getCastedAssignment_3_0()); }
+)
+
+ |(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getSuffixAssignment_3_1()); }
+(rule__ParenthesizedExpression__SuffixAssignment_3_1)
+{ after(grammarAccess.getParenthesizedExpressionAccess().getSuffixAssignment_3_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getTupleAssignment_1_0()); }
+(rule__SuperInvocationExpression__TupleAssignment_1_0)
+{ after(grammarAccess.getSuperInvocationExpressionAccess().getTupleAssignment_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getGroup_1_1()); }
+(rule__SuperInvocationExpression__Group_1_1__0)
+{ after(grammarAccess.getSuperInvocationExpressionAccess().getGroup_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionOrAccessCompletion__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getGroup_0()); }
+(rule__SequenceConstructionOrAccessCompletion__Group_0__0)
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getGroup_0()); }
+)
+
+ |(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getExpressionAssignment_1()); }
+(rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1)
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getExpressionAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAccessCompletionAssignment_0_1_0()); }
+(rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0)
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAccessCompletionAssignment_0_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getSequenceCompletionAssignment_0_1_1()); }
+(rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1)
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getSequenceCompletionAssignment_0_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Alternatives_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getGroup_2_0()); }
+(rule__SequenceConstructionExpression__Group_2_0__0)*
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getGroup_2_0()); }
+)
+
+ |(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getGroup_2_1()); }
+(rule__SequenceConstructionExpression__Group_2_1__0)
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getGroup_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceElement__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceElementAccess().getExpressionParserRuleCall_0()); }
+ ruleExpression
+{ after(grammarAccess.getSequenceElementAccess().getExpressionParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getSequenceElementAccess().getSequenceConstructionExpressionParserRuleCall_1()); }
+ ruleSequenceConstructionExpression
+{ after(grammarAccess.getSequenceElementAccess().getSequenceConstructionExpressionParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DocumentedStatement__CommentAlternatives_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDocumentedStatementAccess().getCommentML_COMMENTTerminalRuleCall_0_0_0()); }
+ RULE_ML_COMMENT
+{ after(grammarAccess.getDocumentedStatementAccess().getCommentML_COMMENTTerminalRuleCall_0_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getDocumentedStatementAccess().getCommentSL_COMMENTTerminalRuleCall_0_0_1()); }
+ RULE_SL_COMMENT
+{ after(grammarAccess.getDocumentedStatementAccess().getCommentSL_COMMENTTerminalRuleCall_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Statement__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getStatementAccess().getAnnotatedStatementParserRuleCall_0()); }
+ ruleAnnotatedStatement
+{ after(grammarAccess.getStatementAccess().getAnnotatedStatementParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getStatementAccess().getInlineStatementParserRuleCall_1()); }
+ ruleInlineStatement
+{ after(grammarAccess.getStatementAccess().getInlineStatementParserRuleCall_1()); }
+)
+
+ |(
+{ before(grammarAccess.getStatementAccess().getBlockStatementParserRuleCall_2()); }
+ ruleBlockStatement
+{ after(grammarAccess.getStatementAccess().getBlockStatementParserRuleCall_2()); }
+)
+
+ |(
+{ before(grammarAccess.getStatementAccess().getEmptyStatementParserRuleCall_3()); }
+ ruleEmptyStatement
+{ after(grammarAccess.getStatementAccess().getEmptyStatementParserRuleCall_3()); }
+)
+
+ |(
+{ before(grammarAccess.getStatementAccess().getLocalNameDeclarationStatementParserRuleCall_4()); }
+ ruleLocalNameDeclarationStatement
+{ after(grammarAccess.getStatementAccess().getLocalNameDeclarationStatementParserRuleCall_4()); }
+)
+
+ |(
+{ before(grammarAccess.getStatementAccess().getIfStatementParserRuleCall_5()); }
+ ruleIfStatement
+{ after(grammarAccess.getStatementAccess().getIfStatementParserRuleCall_5()); }
+)
+
+ |(
+{ before(grammarAccess.getStatementAccess().getSwitchStatementParserRuleCall_6()); }
+ ruleSwitchStatement
+{ after(grammarAccess.getStatementAccess().getSwitchStatementParserRuleCall_6()); }
+)
+
+ |(
+{ before(grammarAccess.getStatementAccess().getWhileStatementParserRuleCall_7()); }
+ ruleWhileStatement
+{ after(grammarAccess.getStatementAccess().getWhileStatementParserRuleCall_7()); }
+)
+
+ |(
+{ before(grammarAccess.getStatementAccess().getDoStatementParserRuleCall_8()); }
+ ruleDoStatement
+{ after(grammarAccess.getStatementAccess().getDoStatementParserRuleCall_8()); }
+)
+
+ |(
+{ before(grammarAccess.getStatementAccess().getForStatementParserRuleCall_9()); }
+ ruleForStatement
+{ after(grammarAccess.getStatementAccess().getForStatementParserRuleCall_9()); }
+)
+
+ |(
+{ before(grammarAccess.getStatementAccess().getBreakStatementParserRuleCall_10()); }
+ ruleBreakStatement
+{ after(grammarAccess.getStatementAccess().getBreakStatementParserRuleCall_10()); }
+)
+
+ |(
+{ before(grammarAccess.getStatementAccess().getReturnStatementParserRuleCall_11()); }
+ ruleReturnStatement
+{ after(grammarAccess.getStatementAccess().getReturnStatementParserRuleCall_11()); }
+)
+
+ |(
+{ before(grammarAccess.getStatementAccess().getAcceptStatementParserRuleCall_12()); }
+ ruleAcceptStatement
+{ after(grammarAccess.getStatementAccess().getAcceptStatementParserRuleCall_12()); }
+)
+
+ |(
+{ before(grammarAccess.getStatementAccess().getClassifyStatementParserRuleCall_13()); }
+ ruleClassifyStatement
+{ after(grammarAccess.getStatementAccess().getClassifyStatementParserRuleCall_13()); }
+)
+
+ |(
+{ before(grammarAccess.getStatementAccess().getInvocationOrAssignementOrDeclarationStatementParserRuleCall_14()); }
+ ruleInvocationOrAssignementOrDeclarationStatement
+{ after(grammarAccess.getStatementAccess().getInvocationOrAssignementOrDeclarationStatementParserRuleCall_14()); }
+)
+
+ |(
+{ before(grammarAccess.getStatementAccess().getSuperInvocationStatementParserRuleCall_15()); }
+ ruleSuperInvocationStatement
+{ after(grammarAccess.getStatementAccess().getSuperInvocationStatementParserRuleCall_15()); }
+)
+
+ |(
+{ before(grammarAccess.getStatementAccess().getThisInvocationStatementParserRuleCall_16()); }
+ ruleThisInvocationStatement
+{ after(grammarAccess.getStatementAccess().getThisInvocationStatementParserRuleCall_16()); }
+)
+
+ |(
+{ before(grammarAccess.getStatementAccess().getInstanceCreationInvocationStatementParserRuleCall_17()); }
+ ruleInstanceCreationInvocationStatement
+{ after(grammarAccess.getStatementAccess().getInstanceCreationInvocationStatementParserRuleCall_17()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getGroup_0()); }
+(rule__LoopVariableDefinition__Group_0__0)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getGroup_0()); }
+)
+
+ |(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getGroup_1()); }
+(rule__LoopVariableDefinition__Group_1__0)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptStatement__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptStatementAccess().getSimpleAcceptAssignment_1_0()); }
+(rule__AcceptStatement__SimpleAcceptAssignment_1_0)
+{ after(grammarAccess.getAcceptStatementAccess().getSimpleAcceptAssignment_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getAcceptStatementAccess().getCompoundAcceptAssignment_1_1()); }
+(rule__AcceptStatement__CompoundAcceptAssignment_1_1)
+{ after(grammarAccess.getAcceptStatementAccess().getCompoundAcceptAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getGroup_0()); }
+(rule__ClassificationClause__Group_0__0)
+{ after(grammarAccess.getClassificationClauseAccess().getGroup_0()); }
+)
+
+ |(
+{ before(grammarAccess.getClassificationClauseAccess().getGroup_1()); }
+(rule__ClassificationClause__Group_1__0)
+{ after(grammarAccess.getClassificationClauseAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getVariableDeclarationCompletionAssignment_1_0()); }
+(rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0)
+{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getVariableDeclarationCompletionAssignment_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAssignmentCompletionAssignment_1_1()); }
+(rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1)
+{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAssignmentCompletionAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__BooleanValue__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBooleanValueAccess().getTRUEEnumLiteralDeclaration_0()); }
+( 'true'
+)
+{ after(grammarAccess.getBooleanValueAccess().getTRUEEnumLiteralDeclaration_0()); }
+)
+
+ |(
+{ before(grammarAccess.getBooleanValueAccess().getFALSEEnumLiteralDeclaration_1()); }
+( 'false'
+)
+{ after(grammarAccess.getBooleanValueAccess().getFALSEEnumLiteralDeclaration_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationKind__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationKindAccess().getCREATEEnumLiteralDeclaration_0()); }
+( 'createLink'
+)
+{ after(grammarAccess.getLinkOperationKindAccess().getCREATEEnumLiteralDeclaration_0()); }
+)
+
+ |(
+{ before(grammarAccess.getLinkOperationKindAccess().getDESTROYEnumLiteralDeclaration_1()); }
+( 'destroyLink'
+)
+{ after(grammarAccess.getLinkOperationKindAccess().getDESTROYEnumLiteralDeclaration_1()); }
+)
+
+ |(
+{ before(grammarAccess.getLinkOperationKindAccess().getCLEAREnumLiteralDeclaration_2()); }
+( 'clearAssoc'
+)
+{ after(grammarAccess.getLinkOperationKindAccess().getCLEAREnumLiteralDeclaration_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperator__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperatorAccess().getSELECTEnumLiteralDeclaration_0()); }
+( 'select'
+)
+{ after(grammarAccess.getSelectOrRejectOperatorAccess().getSELECTEnumLiteralDeclaration_0()); }
+)
+
+ |(
+{ before(grammarAccess.getSelectOrRejectOperatorAccess().getREJECTEnumLiteralDeclaration_1()); }
+( 'reject'
+)
+{ after(grammarAccess.getSelectOrRejectOperatorAccess().getREJECTEnumLiteralDeclaration_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperator__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperatorAccess().getCOLLECTEnumLiteralDeclaration_0()); }
+( 'collect'
+)
+{ after(grammarAccess.getCollectOrIterateOperatorAccess().getCOLLECTEnumLiteralDeclaration_0()); }
+)
+
+ |(
+{ before(grammarAccess.getCollectOrIterateOperatorAccess().getITERATEEnumLiteralDeclaration_1()); }
+( 'iterate'
+)
+{ after(grammarAccess.getCollectOrIterateOperatorAccess().getITERATEEnumLiteralDeclaration_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperator__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getFORALLEnumLiteralDeclaration_0()); }
+( 'forAll'
+)
+{ after(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getFORALLEnumLiteralDeclaration_0()); }
+)
+
+ |(
+{ before(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getEXISTSEnumLiteralDeclaration_1()); }
+( 'exists'
+)
+{ after(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getEXISTSEnumLiteralDeclaration_1()); }
+)
+
+ |(
+{ before(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getONEEnumLiteralDeclaration_2()); }
+( 'one'
+)
+{ after(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getONEEnumLiteralDeclaration_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AnnotationKind__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotationKindAccess().getISOLATEDEnumLiteralDeclaration_0()); }
+( 'isolated'
+)
+{ after(grammarAccess.getAnnotationKindAccess().getISOLATEDEnumLiteralDeclaration_0()); }
+)
+
+ |(
+{ before(grammarAccess.getAnnotationKindAccess().getDETERMINEDEnumLiteralDeclaration_1()); }
+( 'determined'
+)
+{ after(grammarAccess.getAnnotationKindAccess().getDETERMINEDEnumLiteralDeclaration_1()); }
+)
+
+ |(
+{ before(grammarAccess.getAnnotationKindAccess().getASSUREDEnumLiteralDeclaration_2()); }
+( 'assured'
+)
+{ after(grammarAccess.getAnnotationKindAccess().getASSUREDEnumLiteralDeclaration_2()); }
+)
+
+ |(
+{ before(grammarAccess.getAnnotationKindAccess().getPARALLELEnumLiteralDeclaration_3()); }
+( 'parallel'
+)
+{ after(grammarAccess.getAnnotationKindAccess().getPARALLELEnumLiteralDeclaration_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignmentOperator__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignmentOperatorAccess().getASSIGNEnumLiteralDeclaration_0()); }
+( '='
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getASSIGNEnumLiteralDeclaration_0()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getPLUSASSIGNEnumLiteralDeclaration_1()); }
+( '+='
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getPLUSASSIGNEnumLiteralDeclaration_1()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getMINUSASSIGNEnumLiteralDeclaration_2()); }
+( '-='
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getMINUSASSIGNEnumLiteralDeclaration_2()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getMULTASSIGNEnumLiteralDeclaration_3()); }
+( '*='
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getMULTASSIGNEnumLiteralDeclaration_3()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getMODASSIGNEnumLiteralDeclaration_4()); }
+( '%='
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getMODASSIGNEnumLiteralDeclaration_4()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getDIVASSIGNEnumLiteralDeclaration_5()); }
+( '/='
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getDIVASSIGNEnumLiteralDeclaration_5()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getANDASSIGNEnumLiteralDeclaration_6()); }
+( '&='
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getANDASSIGNEnumLiteralDeclaration_6()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getORASSIGNEnumLiteralDeclaration_7()); }
+( '|='
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getORASSIGNEnumLiteralDeclaration_7()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getXORASSIGNEnumLiteralDeclaration_8()); }
+( '^='
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getXORASSIGNEnumLiteralDeclaration_8()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getLSHIFTASSIGNEnumLiteralDeclaration_9()); }
+( '<<='
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getLSHIFTASSIGNEnumLiteralDeclaration_9()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getRSHIFTASSIGNEnumLiteralDeclaration_10()); }
+( '>>='
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getRSHIFTASSIGNEnumLiteralDeclaration_10()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getURSHIFTASSIGNEnumLiteralDeclaration_11()); }
+( '>>>='
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getURSHIFTASSIGNEnumLiteralDeclaration_11()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+rule__Test__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Test__Group__0__Impl
+ rule__Test__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Test__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTestAccess().getGroup_0()); }
+(rule__Test__Group_0__0)*
+{ after(grammarAccess.getTestAccess().getGroup_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Test__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Test__Group__1__Impl
+ rule__Test__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Test__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTestAccess().getGroup_1()); }
+(rule__Test__Group_1__0)*
+{ after(grammarAccess.getTestAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Test__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Test__Group__2__Impl
+ rule__Test__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Test__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTestAccess().getGroup_2()); }
+(rule__Test__Group_2__0)*
+{ after(grammarAccess.getTestAccess().getGroup_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Test__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Test__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Test__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTestAccess().getGroup_3()); }
+(rule__Test__Group_3__0)
+{ after(grammarAccess.getTestAccess().getGroup_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__Test__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Test__Group_0__0__Impl
+ rule__Test__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Test__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTestAccess().getTestExpressionKeyword_0_0()); }
+
+ 'testExpression'
+
+{ after(grammarAccess.getTestAccess().getTestExpressionKeyword_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Test__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Test__Group_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Test__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTestAccess().getExpressionAssignment_0_1()); }
+(rule__Test__ExpressionAssignment_0_1)
+{ after(grammarAccess.getTestAccess().getExpressionAssignment_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Test__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Test__Group_1__0__Impl
+ rule__Test__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Test__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTestAccess().getTestAssignmentExpressionKeyword_1_0()); }
+
+ 'testAssignmentExpression'
+
+{ after(grammarAccess.getTestAccess().getTestAssignmentExpressionKeyword_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Test__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Test__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Test__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTestAccess().getAssignExpressionAssignment_1_1()); }
+(rule__Test__AssignExpressionAssignment_1_1)
+{ after(grammarAccess.getTestAccess().getAssignExpressionAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Test__Group_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Test__Group_2__0__Impl
+ rule__Test__Group_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Test__Group_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTestAccess().getTestStatementKeyword_2_0()); }
+
+ 'testStatement'
+
+{ after(grammarAccess.getTestAccess().getTestStatementKeyword_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Test__Group_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Test__Group_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Test__Group_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTestAccess().getStatementsAssignment_2_1()); }
+(rule__Test__StatementsAssignment_2_1)
+{ after(grammarAccess.getTestAccess().getStatementsAssignment_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Test__Group_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Test__Group_3__0__Impl
+ rule__Test__Group_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Test__Group_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTestAccess().getTestBlockKeyword_3_0()); }
+
+ 'testBlock'
+
+{ after(grammarAccess.getTestAccess().getTestBlockKeyword_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Test__Group_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Test__Group_3__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Test__Group_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTestAccess().getBlockAssignment_3_1()); }
+(rule__Test__BlockAssignment_3_1)
+{ after(grammarAccess.getTestAccess().getBlockAssignment_3_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__NameExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NameExpression__Group__0__Impl
+ rule__NameExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getAlternatives_0()); }
+(rule__NameExpression__Alternatives_0)
+{ after(grammarAccess.getNameExpressionAccess().getAlternatives_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__NameExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NameExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getSuffixAssignment_1()); }
+(rule__NameExpression__SuffixAssignment_1)?
+{ after(grammarAccess.getNameExpressionAccess().getSuffixAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__NameExpression__Group_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NameExpression__Group_0_0__0__Impl
+ rule__NameExpression__Group_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Group_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPrefixOpAssignment_0_0_0()); }
+(rule__NameExpression__PrefixOpAssignment_0_0_0)
+{ after(grammarAccess.getNameExpressionAccess().getPrefixOpAssignment_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__NameExpression__Group_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NameExpression__Group_0_0__1__Impl
+ rule__NameExpression__Group_0_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Group_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPathAssignment_0_0_1()); }
+(rule__NameExpression__PathAssignment_0_0_1)?
+{ after(grammarAccess.getNameExpressionAccess().getPathAssignment_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__NameExpression__Group_0_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NameExpression__Group_0_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Group_0_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getIdAssignment_0_0_2()); }
+(rule__NameExpression__IdAssignment_0_0_2)
+{ after(grammarAccess.getNameExpressionAccess().getIdAssignment_0_0_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__NameExpression__Group_0_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NameExpression__Group_0_1__0__Impl
+ rule__NameExpression__Group_0_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Group_0_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPathAssignment_0_1_0()); }
+(rule__NameExpression__PathAssignment_0_1_0)?
+{ after(grammarAccess.getNameExpressionAccess().getPathAssignment_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__NameExpression__Group_0_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NameExpression__Group_0_1__1__Impl
+ rule__NameExpression__Group_0_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Group_0_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getIdAssignment_0_1_1()); }
+(rule__NameExpression__IdAssignment_0_1_1)
+{ after(grammarAccess.getNameExpressionAccess().getIdAssignment_0_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__NameExpression__Group_0_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NameExpression__Group_0_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Group_0_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getAlternatives_0_1_2()); }
+(rule__NameExpression__Alternatives_0_1_2)?
+{ after(grammarAccess.getNameExpressionAccess().getAlternatives_0_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__QualifiedNamePath__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedNamePath__Group__0__Impl
+ rule__QualifiedNamePath__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNamePath__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getQualifiedNamePathAccess().getNamespaceAssignment_0()); }
+(rule__QualifiedNamePath__NamespaceAssignment_0)
+{ after(grammarAccess.getQualifiedNamePathAccess().getNamespaceAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedNamePath__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedNamePath__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNamePath__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getQualifiedNamePathAccess().getColonColonKeyword_1()); }
+
+ '::'
+
+{ after(grammarAccess.getQualifiedNamePathAccess().getColonColonKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__UnqualifiedName__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__UnqualifiedName__Group__0__Impl
+ rule__UnqualifiedName__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__UnqualifiedName__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getUnqualifiedNameAccess().getNameAssignment_0()); }
+(rule__UnqualifiedName__NameAssignment_0)
+{ after(grammarAccess.getUnqualifiedNameAccess().getNameAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__UnqualifiedName__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__UnqualifiedName__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__UnqualifiedName__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getUnqualifiedNameAccess().getTemplateBindingAssignment_1()); }
+(rule__UnqualifiedName__TemplateBindingAssignment_1)?
+{ after(grammarAccess.getUnqualifiedNameAccess().getTemplateBindingAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TemplateBinding__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TemplateBinding__Group__0__Impl
+ rule__TemplateBinding__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TemplateBinding__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTemplateBindingAccess().getLessThanSignKeyword_0()); }
+
+ '<'
+
+{ after(grammarAccess.getTemplateBindingAccess().getLessThanSignKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TemplateBinding__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TemplateBinding__Group__1__Impl
+ rule__TemplateBinding__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TemplateBinding__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTemplateBindingAccess().getBindingsAssignment_1()); }
+(rule__TemplateBinding__BindingsAssignment_1)
+{ after(grammarAccess.getTemplateBindingAccess().getBindingsAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TemplateBinding__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TemplateBinding__Group__2__Impl
+ rule__TemplateBinding__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TemplateBinding__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTemplateBindingAccess().getGroup_2()); }
+(rule__TemplateBinding__Group_2__0)*
+{ after(grammarAccess.getTemplateBindingAccess().getGroup_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TemplateBinding__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TemplateBinding__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TemplateBinding__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTemplateBindingAccess().getGreaterThanSignKeyword_3()); }
+
+ '>'
+
+{ after(grammarAccess.getTemplateBindingAccess().getGreaterThanSignKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TemplateBinding__Group_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TemplateBinding__Group_2__0__Impl
+ rule__TemplateBinding__Group_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TemplateBinding__Group_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTemplateBindingAccess().getCommaKeyword_2_0()); }
+
+ ','
+
+{ after(grammarAccess.getTemplateBindingAccess().getCommaKeyword_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TemplateBinding__Group_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TemplateBinding__Group_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TemplateBinding__Group_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTemplateBindingAccess().getBindingsAssignment_2_1()); }
+(rule__TemplateBinding__BindingsAssignment_2_1)
+{ after(grammarAccess.getTemplateBindingAccess().getBindingsAssignment_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__NamedTemplateBinding__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NamedTemplateBinding__Group__0__Impl
+ rule__NamedTemplateBinding__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NamedTemplateBinding__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNamedTemplateBindingAccess().getFormalAssignment_0()); }
+(rule__NamedTemplateBinding__FormalAssignment_0)
+{ after(grammarAccess.getNamedTemplateBindingAccess().getFormalAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__NamedTemplateBinding__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NamedTemplateBinding__Group__1__Impl
+ rule__NamedTemplateBinding__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NamedTemplateBinding__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNamedTemplateBindingAccess().getEqualsSignGreaterThanSignKeyword_1()); }
+
+ '=>'
+
+{ after(grammarAccess.getNamedTemplateBindingAccess().getEqualsSignGreaterThanSignKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__NamedTemplateBinding__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NamedTemplateBinding__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NamedTemplateBinding__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNamedTemplateBindingAccess().getActualAssignment_2()); }
+(rule__NamedTemplateBinding__ActualAssignment_2)
+{ after(grammarAccess.getNamedTemplateBindingAccess().getActualAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__QualifiedNameWithBinding__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedNameWithBinding__Group__0__Impl
+ rule__QualifiedNameWithBinding__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithBinding__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getIdAssignment_0()); }
+(rule__QualifiedNameWithBinding__IdAssignment_0)
+{ after(grammarAccess.getQualifiedNameWithBindingAccess().getIdAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedNameWithBinding__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedNameWithBinding__Group__1__Impl
+ rule__QualifiedNameWithBinding__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithBinding__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getBindingAssignment_1()); }
+(rule__QualifiedNameWithBinding__BindingAssignment_1)?
+{ after(grammarAccess.getQualifiedNameWithBindingAccess().getBindingAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedNameWithBinding__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedNameWithBinding__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithBinding__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getGroup_2()); }
+(rule__QualifiedNameWithBinding__Group_2__0)?
+{ after(grammarAccess.getQualifiedNameWithBindingAccess().getGroup_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__QualifiedNameWithBinding__Group_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedNameWithBinding__Group_2__0__Impl
+ rule__QualifiedNameWithBinding__Group_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithBinding__Group_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getColonColonKeyword_2_0()); }
+
+ '::'
+
+{ after(grammarAccess.getQualifiedNameWithBindingAccess().getColonColonKeyword_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedNameWithBinding__Group_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedNameWithBinding__Group_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithBinding__Group_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getRemainingAssignment_2_1()); }
+(rule__QualifiedNameWithBinding__RemainingAssignment_2_1)
+{ after(grammarAccess.getQualifiedNameWithBindingAccess().getRemainingAssignment_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Tuple__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Tuple__Group__0__Impl
+ rule__Tuple__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Tuple__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTupleAccess().getTupleAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTupleAccess().getTupleAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Tuple__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Tuple__Group__1__Impl
+ rule__Tuple__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Tuple__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTupleAccess().getLeftParenthesisKeyword_1()); }
+
+ '('
+
+{ after(grammarAccess.getTupleAccess().getLeftParenthesisKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Tuple__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Tuple__Group__2__Impl
+ rule__Tuple__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Tuple__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTupleAccess().getGroup_2()); }
+(rule__Tuple__Group_2__0)?
+{ after(grammarAccess.getTupleAccess().getGroup_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Tuple__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Tuple__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Tuple__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTupleAccess().getRightParenthesisKeyword_3()); }
+
+ ')'
+
+{ after(grammarAccess.getTupleAccess().getRightParenthesisKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__Tuple__Group_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Tuple__Group_2__0__Impl
+ rule__Tuple__Group_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Tuple__Group_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTupleAccess().getTupleElementsAssignment_2_0()); }
+(rule__Tuple__TupleElementsAssignment_2_0)
+{ after(grammarAccess.getTupleAccess().getTupleElementsAssignment_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Tuple__Group_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Tuple__Group_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Tuple__Group_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTupleAccess().getGroup_2_1()); }
+(rule__Tuple__Group_2_1__0)*
+{ after(grammarAccess.getTupleAccess().getGroup_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Tuple__Group_2_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Tuple__Group_2_1__0__Impl
+ rule__Tuple__Group_2_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Tuple__Group_2_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTupleAccess().getCommaKeyword_2_1_0()); }
+
+ ','
+
+{ after(grammarAccess.getTupleAccess().getCommaKeyword_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Tuple__Group_2_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Tuple__Group_2_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Tuple__Group_2_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTupleAccess().getTupleElementsAssignment_2_1_1()); }
+(rule__Tuple__TupleElementsAssignment_2_1_1)
+{ after(grammarAccess.getTupleAccess().getTupleElementsAssignment_2_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ConditionalTestExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConditionalTestExpression__Group__0__Impl
+ rule__ConditionalTestExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getExpAssignment_0()); }
+(rule__ConditionalTestExpression__ExpAssignment_0)
+{ after(grammarAccess.getConditionalTestExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ConditionalTestExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConditionalTestExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getGroup_1()); }
+(rule__ConditionalTestExpression__Group_1__0)?
+{ after(grammarAccess.getConditionalTestExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ConditionalTestExpression__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConditionalTestExpression__Group_1__0__Impl
+ rule__ConditionalTestExpression__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getQuestionMarkKeyword_1_0()); }
+
+ '?'
+
+{ after(grammarAccess.getConditionalTestExpressionAccess().getQuestionMarkKeyword_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ConditionalTestExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConditionalTestExpression__Group_1__1__Impl
+ rule__ConditionalTestExpression__Group_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getWhenTrueAssignment_1_1()); }
+(rule__ConditionalTestExpression__WhenTrueAssignment_1_1)
+{ after(grammarAccess.getConditionalTestExpressionAccess().getWhenTrueAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ConditionalTestExpression__Group_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConditionalTestExpression__Group_1__2__Impl
+ rule__ConditionalTestExpression__Group_1__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__Group_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getColonKeyword_1_2()); }
+
+ ':'
+
+{ after(grammarAccess.getConditionalTestExpressionAccess().getColonKeyword_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ConditionalTestExpression__Group_1__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConditionalTestExpression__Group_1__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__Group_1__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getWhenFalseAssignment_1_3()); }
+(rule__ConditionalTestExpression__WhenFalseAssignment_1_3)
+{ after(grammarAccess.getConditionalTestExpressionAccess().getWhenFalseAssignment_1_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__ConditionalOrExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConditionalOrExpression__Group__0__Impl
+ rule__ConditionalOrExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalOrExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalOrExpressionAccess().getExpAssignment_0()); }
+(rule__ConditionalOrExpression__ExpAssignment_0)
+{ after(grammarAccess.getConditionalOrExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ConditionalOrExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConditionalOrExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalOrExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalOrExpressionAccess().getGroup_1()); }
+(rule__ConditionalOrExpression__Group_1__0)*
+{ after(grammarAccess.getConditionalOrExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ConditionalOrExpression__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConditionalOrExpression__Group_1__0__Impl
+ rule__ConditionalOrExpression__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalOrExpression__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalOrExpressionAccess().getVerticalLineVerticalLineKeyword_1_0()); }
+
+ '||'
+
+{ after(grammarAccess.getConditionalOrExpressionAccess().getVerticalLineVerticalLineKeyword_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ConditionalOrExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConditionalOrExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalOrExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalOrExpressionAccess().getExpAssignment_1_1()); }
+(rule__ConditionalOrExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getConditionalOrExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ConditionalAndExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConditionalAndExpression__Group__0__Impl
+ rule__ConditionalAndExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalAndExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalAndExpressionAccess().getExpAssignment_0()); }
+(rule__ConditionalAndExpression__ExpAssignment_0)
+{ after(grammarAccess.getConditionalAndExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ConditionalAndExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConditionalAndExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalAndExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalAndExpressionAccess().getGroup_1()); }
+(rule__ConditionalAndExpression__Group_1__0)*
+{ after(grammarAccess.getConditionalAndExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ConditionalAndExpression__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConditionalAndExpression__Group_1__0__Impl
+ rule__ConditionalAndExpression__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalAndExpression__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalAndExpressionAccess().getAmpersandAmpersandKeyword_1_0()); }
+
+ '&&'
+
+{ after(grammarAccess.getConditionalAndExpressionAccess().getAmpersandAmpersandKeyword_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ConditionalAndExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConditionalAndExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalAndExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalAndExpressionAccess().getExpAssignment_1_1()); }
+(rule__ConditionalAndExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getConditionalAndExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__InclusiveOrExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InclusiveOrExpression__Group__0__Impl
+ rule__InclusiveOrExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InclusiveOrExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInclusiveOrExpressionAccess().getExpAssignment_0()); }
+(rule__InclusiveOrExpression__ExpAssignment_0)
+{ after(grammarAccess.getInclusiveOrExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InclusiveOrExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InclusiveOrExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InclusiveOrExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInclusiveOrExpressionAccess().getGroup_1()); }
+(rule__InclusiveOrExpression__Group_1__0)*
+{ after(grammarAccess.getInclusiveOrExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__InclusiveOrExpression__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InclusiveOrExpression__Group_1__0__Impl
+ rule__InclusiveOrExpression__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InclusiveOrExpression__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInclusiveOrExpressionAccess().getVerticalLineKeyword_1_0()); }
+
+ '|'
+
+{ after(grammarAccess.getInclusiveOrExpressionAccess().getVerticalLineKeyword_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InclusiveOrExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InclusiveOrExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InclusiveOrExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInclusiveOrExpressionAccess().getExpAssignment_1_1()); }
+(rule__InclusiveOrExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getInclusiveOrExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ExclusiveOrExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExclusiveOrExpression__Group__0__Impl
+ rule__ExclusiveOrExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExclusiveOrExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExclusiveOrExpressionAccess().getExpAssignment_0()); }
+(rule__ExclusiveOrExpression__ExpAssignment_0)
+{ after(grammarAccess.getExclusiveOrExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ExclusiveOrExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExclusiveOrExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExclusiveOrExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExclusiveOrExpressionAccess().getGroup_1()); }
+(rule__ExclusiveOrExpression__Group_1__0)*
+{ after(grammarAccess.getExclusiveOrExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ExclusiveOrExpression__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExclusiveOrExpression__Group_1__0__Impl
+ rule__ExclusiveOrExpression__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExclusiveOrExpression__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExclusiveOrExpressionAccess().getCircumflexAccentKeyword_1_0()); }
+
+ '^'
+
+{ after(grammarAccess.getExclusiveOrExpressionAccess().getCircumflexAccentKeyword_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ExclusiveOrExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExclusiveOrExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExclusiveOrExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExclusiveOrExpressionAccess().getExpAssignment_1_1()); }
+(rule__ExclusiveOrExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getExclusiveOrExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+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().getExpAssignment_0()); }
+(rule__AndExpression__ExpAssignment_0)
+{ after(grammarAccess.getAndExpressionAccess().getExpAssignment_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().getAmpersandKeyword_1_0()); }
+
+ '&'
+
+{ after(grammarAccess.getAndExpressionAccess().getAmpersandKeyword_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AndExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AndExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AndExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAndExpressionAccess().getExpAssignment_1_1()); }
+(rule__AndExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getAndExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__EqualityExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__EqualityExpression__Group__0__Impl
+ rule__EqualityExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__EqualityExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getExpAssignment_0()); }
+(rule__EqualityExpression__ExpAssignment_0)
+{ after(grammarAccess.getEqualityExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__EqualityExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__EqualityExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__EqualityExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getGroup_1()); }
+(rule__EqualityExpression__Group_1__0)*
+{ after(grammarAccess.getEqualityExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__EqualityExpression__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__EqualityExpression__Group_1__0__Impl
+ rule__EqualityExpression__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__EqualityExpression__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getOpAssignment_1_0()); }
+(rule__EqualityExpression__OpAssignment_1_0)
+{ after(grammarAccess.getEqualityExpressionAccess().getOpAssignment_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__EqualityExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__EqualityExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__EqualityExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getExpAssignment_1_1()); }
+(rule__EqualityExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getEqualityExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ClassificationExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassificationExpression__Group__0__Impl
+ rule__ClassificationExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getExpAssignment_0()); }
+(rule__ClassificationExpression__ExpAssignment_0)
+{ after(grammarAccess.getClassificationExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassificationExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassificationExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getGroup_1()); }
+(rule__ClassificationExpression__Group_1__0)?
+{ after(grammarAccess.getClassificationExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ClassificationExpression__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassificationExpression__Group_1__0__Impl
+ rule__ClassificationExpression__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationExpression__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getOpAssignment_1_0()); }
+(rule__ClassificationExpression__OpAssignment_1_0)
+{ after(grammarAccess.getClassificationExpressionAccess().getOpAssignment_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassificationExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassificationExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getTypeNameAssignment_1_1()); }
+(rule__ClassificationExpression__TypeNameAssignment_1_1)
+{ after(grammarAccess.getClassificationExpressionAccess().getTypeNameAssignment_1_1()); }
+)
+
+;
+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().getLeftAssignment_0()); }
+(rule__RelationalExpression__LeftAssignment_0)
+{ after(grammarAccess.getRelationalExpressionAccess().getLeftAssignment_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().getOpAssignment_1_0()); }
+(rule__RelationalExpression__OpAssignment_1_0)
+{ after(grammarAccess.getRelationalExpressionAccess().getOpAssignment_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__RelationalExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RelationalExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RelationalExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_1()); }
+(rule__RelationalExpression__RightAssignment_1_1)
+{ after(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ShiftExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ShiftExpression__Group__0__Impl
+ rule__ShiftExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ShiftExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getShiftExpressionAccess().getExpAssignment_0()); }
+(rule__ShiftExpression__ExpAssignment_0)
+{ after(grammarAccess.getShiftExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ShiftExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ShiftExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ShiftExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getShiftExpressionAccess().getGroup_1()); }
+(rule__ShiftExpression__Group_1__0)?
+{ after(grammarAccess.getShiftExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ShiftExpression__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ShiftExpression__Group_1__0__Impl
+ rule__ShiftExpression__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ShiftExpression__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getShiftExpressionAccess().getOpAssignment_1_0()); }
+(rule__ShiftExpression__OpAssignment_1_0)
+{ after(grammarAccess.getShiftExpressionAccess().getOpAssignment_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ShiftExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ShiftExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ShiftExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getShiftExpressionAccess().getExpAssignment_1_1()); }
+(rule__ShiftExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getShiftExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+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().getExpAssignment_0()); }
+(rule__AdditiveExpression__ExpAssignment_0)
+{ after(grammarAccess.getAdditiveExpressionAccess().getExpAssignment_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().getOpAssignment_1_0()); }
+(rule__AdditiveExpression__OpAssignment_1_0)
+{ after(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AdditiveExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AdditiveExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AdditiveExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAdditiveExpressionAccess().getExpAssignment_1_1()); }
+(rule__AdditiveExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getAdditiveExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+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().getExpAssignment_0()); }
+(rule__MultiplicativeExpression__ExpAssignment_0)
+{ after(grammarAccess.getMultiplicativeExpressionAccess().getExpAssignment_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().getOpAssignment_1_0()); }
+(rule__MultiplicativeExpression__OpAssignment_1_0)
+{ after(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__MultiplicativeExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__MultiplicativeExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__MultiplicativeExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getExpAssignment_1_1()); }
+(rule__MultiplicativeExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getMultiplicativeExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+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().getOpAssignment_0()); }
+(rule__UnaryExpression__OpAssignment_0)?
+{ after(grammarAccess.getUnaryExpressionAccess().getOpAssignment_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().getExpAssignment_1()); }
+(rule__UnaryExpression__ExpAssignment_1)
+{ after(grammarAccess.getUnaryExpressionAccess().getExpAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__OperationCallExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OperationCallExpression__Group__0__Impl
+ rule__OperationCallExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OperationCallExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getOperationCallExpressionAccess().getFullStopKeyword_0()); }
+
+ '.'
+
+{ after(grammarAccess.getOperationCallExpressionAccess().getFullStopKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__OperationCallExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OperationCallExpression__Group__1__Impl
+ rule__OperationCallExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OperationCallExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getOperationCallExpressionAccess().getOperationNameAssignment_1()); }
+(rule__OperationCallExpression__OperationNameAssignment_1)
+{ after(grammarAccess.getOperationCallExpressionAccess().getOperationNameAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__OperationCallExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OperationCallExpression__Group__2__Impl
+ rule__OperationCallExpression__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OperationCallExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getOperationCallExpressionAccess().getTupleAssignment_2()); }
+(rule__OperationCallExpression__TupleAssignment_2)
+{ after(grammarAccess.getOperationCallExpressionAccess().getTupleAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__OperationCallExpression__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OperationCallExpression__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OperationCallExpression__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getOperationCallExpressionAccess().getSuffixAssignment_3()); }
+(rule__OperationCallExpression__SuffixAssignment_3)?
+{ after(grammarAccess.getOperationCallExpressionAccess().getSuffixAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__PropertyCallExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PropertyCallExpression__Group__0__Impl
+ rule__PropertyCallExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getFullStopKeyword_0()); }
+
+ '.'
+
+{ after(grammarAccess.getPropertyCallExpressionAccess().getFullStopKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PropertyCallExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PropertyCallExpression__Group__1__Impl
+ rule__PropertyCallExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getPropertyNameAssignment_1()); }
+(rule__PropertyCallExpression__PropertyNameAssignment_1)
+{ after(grammarAccess.getPropertyCallExpressionAccess().getPropertyNameAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PropertyCallExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PropertyCallExpression__Group__2__Impl
+ rule__PropertyCallExpression__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getGroup_2()); }
+(rule__PropertyCallExpression__Group_2__0)?
+{ after(grammarAccess.getPropertyCallExpressionAccess().getGroup_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PropertyCallExpression__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PropertyCallExpression__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getSuffixAssignment_3()); }
+(rule__PropertyCallExpression__SuffixAssignment_3)?
+{ after(grammarAccess.getPropertyCallExpressionAccess().getSuffixAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__PropertyCallExpression__Group_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PropertyCallExpression__Group_2__0__Impl
+ rule__PropertyCallExpression__Group_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__Group_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getLeftSquareBracketKeyword_2_0()); }
+
+ '['
+
+{ after(grammarAccess.getPropertyCallExpressionAccess().getLeftSquareBracketKeyword_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PropertyCallExpression__Group_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PropertyCallExpression__Group_2__1__Impl
+ rule__PropertyCallExpression__Group_2__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__Group_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getIndexAssignment_2_1()); }
+(rule__PropertyCallExpression__IndexAssignment_2_1)
+{ after(grammarAccess.getPropertyCallExpressionAccess().getIndexAssignment_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PropertyCallExpression__Group_2__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PropertyCallExpression__Group_2__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__Group_2__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getRightSquareBracketKeyword_2_2()); }
+
+ ']'
+
+{ after(grammarAccess.getPropertyCallExpressionAccess().getRightSquareBracketKeyword_2_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__LinkOperationExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LinkOperationExpression__Group__0__Impl
+ rule__LinkOperationExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationExpressionAccess().getFullStopKeyword_0()); }
+
+ '.'
+
+{ after(grammarAccess.getLinkOperationExpressionAccess().getFullStopKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LinkOperationExpression__Group__1__Impl
+ rule__LinkOperationExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationExpressionAccess().getKindAssignment_1()); }
+(rule__LinkOperationExpression__KindAssignment_1)
+{ after(grammarAccess.getLinkOperationExpressionAccess().getKindAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LinkOperationExpression__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationExpressionAccess().getTupleAssignment_2()); }
+(rule__LinkOperationExpression__TupleAssignment_2)
+{ after(grammarAccess.getLinkOperationExpressionAccess().getTupleAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__LinkOperationTuple__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LinkOperationTuple__Group__0__Impl
+ rule__LinkOperationTuple__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTuple__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getLeftParenthesisKeyword_0()); }
+
+ '('
+
+{ after(grammarAccess.getLinkOperationTupleAccess().getLeftParenthesisKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTuple__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LinkOperationTuple__Group__1__Impl
+ rule__LinkOperationTuple__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTuple__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementAssignment_1()); }
+(rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1)
+{ after(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTuple__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LinkOperationTuple__Group__2__Impl
+ rule__LinkOperationTuple__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTuple__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getGroup_2()); }
+(rule__LinkOperationTuple__Group_2__0)*
+{ after(grammarAccess.getLinkOperationTupleAccess().getGroup_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTuple__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LinkOperationTuple__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTuple__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getRightParenthesisKeyword_3()); }
+
+ ')'
+
+{ after(grammarAccess.getLinkOperationTupleAccess().getRightParenthesisKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__LinkOperationTuple__Group_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LinkOperationTuple__Group_2__0__Impl
+ rule__LinkOperationTuple__Group_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTuple__Group_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getCommaKeyword_2_0()); }
+
+ ','
+
+{ after(grammarAccess.getLinkOperationTupleAccess().getCommaKeyword_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTuple__Group_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LinkOperationTuple__Group_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTuple__Group_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementAssignment_2_1()); }
+(rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1)
+{ after(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementAssignment_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__LinkOperationTupleElement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LinkOperationTupleElement__Group__0__Impl
+ rule__LinkOperationTupleElement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getRoleAssignment_0()); }
+(rule__LinkOperationTupleElement__RoleAssignment_0)
+{ after(grammarAccess.getLinkOperationTupleElementAccess().getRoleAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTupleElement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LinkOperationTupleElement__Group__1__Impl
+ rule__LinkOperationTupleElement__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getGroup_1()); }
+(rule__LinkOperationTupleElement__Group_1__0)?
+{ after(grammarAccess.getLinkOperationTupleElementAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTupleElement__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LinkOperationTupleElement__Group__2__Impl
+ rule__LinkOperationTupleElement__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getEqualsSignGreaterThanSignKeyword_2()); }
+
+ '=>'
+
+{ after(grammarAccess.getLinkOperationTupleElementAccess().getEqualsSignGreaterThanSignKeyword_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTupleElement__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LinkOperationTupleElement__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getObjectAssignment_3()); }
+(rule__LinkOperationTupleElement__ObjectAssignment_3)
+{ after(grammarAccess.getLinkOperationTupleElementAccess().getObjectAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__LinkOperationTupleElement__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LinkOperationTupleElement__Group_1__0__Impl
+ rule__LinkOperationTupleElement__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getLeftSquareBracketKeyword_1_0()); }
+
+ '['
+
+{ after(grammarAccess.getLinkOperationTupleElementAccess().getLeftSquareBracketKeyword_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTupleElement__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LinkOperationTupleElement__Group_1__1__Impl
+ rule__LinkOperationTupleElement__Group_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getRoleIndexAssignment_1_1()); }
+(rule__LinkOperationTupleElement__RoleIndexAssignment_1_1)
+{ after(grammarAccess.getLinkOperationTupleElementAccess().getRoleIndexAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTupleElement__Group_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LinkOperationTupleElement__Group_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__Group_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getRightSquareBracketKeyword_1_2()); }
+
+ ']'
+
+{ after(grammarAccess.getLinkOperationTupleElementAccess().getRightSquareBracketKeyword_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__SequenceOperationExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceOperationExpression__Group__0__Impl
+ rule__SequenceOperationExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceOperationExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceOperationExpressionAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+
+ '->'
+
+{ after(grammarAccess.getSequenceOperationExpressionAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SequenceOperationExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceOperationExpression__Group__1__Impl
+ rule__SequenceOperationExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceOperationExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceOperationExpressionAccess().getOperationNameAssignment_1()); }
+(rule__SequenceOperationExpression__OperationNameAssignment_1)
+{ after(grammarAccess.getSequenceOperationExpressionAccess().getOperationNameAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SequenceOperationExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceOperationExpression__Group__2__Impl
+ rule__SequenceOperationExpression__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceOperationExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceOperationExpressionAccess().getTupleAssignment_2()); }
+(rule__SequenceOperationExpression__TupleAssignment_2)
+{ after(grammarAccess.getSequenceOperationExpressionAccess().getTupleAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SequenceOperationExpression__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceOperationExpression__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceOperationExpression__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceOperationExpressionAccess().getSuffixAssignment_3()); }
+(rule__SequenceOperationExpression__SuffixAssignment_3)?
+{ after(grammarAccess.getSequenceOperationExpressionAccess().getSuffixAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__SequenceReductionExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceReductionExpression__Group__0__Impl
+ rule__SequenceReductionExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceReductionExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+
+ '->'
+
+{ after(grammarAccess.getSequenceReductionExpressionAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SequenceReductionExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceReductionExpression__Group__1__Impl
+ rule__SequenceReductionExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceReductionExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getReduceKeyword_1()); }
+
+ 'reduce'
+
+{ after(grammarAccess.getSequenceReductionExpressionAccess().getReduceKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SequenceReductionExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceReductionExpression__Group__2__Impl
+ rule__SequenceReductionExpression__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceReductionExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedAssignment_2()); }
+(rule__SequenceReductionExpression__IsOrderedAssignment_2)?
+{ after(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SequenceReductionExpression__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceReductionExpression__Group__3__Impl
+ rule__SequenceReductionExpression__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceReductionExpression__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getBehaviorAssignment_3()); }
+(rule__SequenceReductionExpression__BehaviorAssignment_3)
+{ after(grammarAccess.getSequenceReductionExpressionAccess().getBehaviorAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SequenceReductionExpression__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceReductionExpression__Group__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceReductionExpression__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getSuffixAssignment_4()); }
+(rule__SequenceReductionExpression__SuffixAssignment_4)?
+{ after(grammarAccess.getSequenceReductionExpressionAccess().getSuffixAssignment_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__SelectOrRejectOperation__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SelectOrRejectOperation__Group__0__Impl
+ rule__SelectOrRejectOperation__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+
+ '->'
+
+{ after(grammarAccess.getSelectOrRejectOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SelectOrRejectOperation__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SelectOrRejectOperation__Group__1__Impl
+ rule__SelectOrRejectOperation__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getOpAssignment_1()); }
+(rule__SelectOrRejectOperation__OpAssignment_1)
+{ after(grammarAccess.getSelectOrRejectOperationAccess().getOpAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SelectOrRejectOperation__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SelectOrRejectOperation__Group__2__Impl
+ rule__SelectOrRejectOperation__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getNameAssignment_2()); }
+(rule__SelectOrRejectOperation__NameAssignment_2)
+{ after(grammarAccess.getSelectOrRejectOperationAccess().getNameAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SelectOrRejectOperation__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SelectOrRejectOperation__Group__3__Impl
+ rule__SelectOrRejectOperation__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getLeftParenthesisKeyword_3()); }
+
+ '('
+
+{ after(grammarAccess.getSelectOrRejectOperationAccess().getLeftParenthesisKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SelectOrRejectOperation__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SelectOrRejectOperation__Group__4__Impl
+ rule__SelectOrRejectOperation__Group__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getExprAssignment_4()); }
+(rule__SelectOrRejectOperation__ExprAssignment_4)
+{ after(grammarAccess.getSelectOrRejectOperationAccess().getExprAssignment_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SelectOrRejectOperation__Group__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SelectOrRejectOperation__Group__5__Impl
+ rule__SelectOrRejectOperation__Group__6
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__Group__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getRightParenthesisKeyword_5()); }
+
+ ')'
+
+{ after(grammarAccess.getSelectOrRejectOperationAccess().getRightParenthesisKeyword_5()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SelectOrRejectOperation__Group__6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SelectOrRejectOperation__Group__6__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__Group__6__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getSuffixAssignment_6()); }
+(rule__SelectOrRejectOperation__SuffixAssignment_6)?
+{ after(grammarAccess.getSelectOrRejectOperationAccess().getSuffixAssignment_6()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__CollectOrIterateOperation__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CollectOrIterateOperation__Group__0__Impl
+ rule__CollectOrIterateOperation__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+
+ '->'
+
+{ after(grammarAccess.getCollectOrIterateOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__CollectOrIterateOperation__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CollectOrIterateOperation__Group__1__Impl
+ rule__CollectOrIterateOperation__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getOpAssignment_1()); }
+(rule__CollectOrIterateOperation__OpAssignment_1)
+{ after(grammarAccess.getCollectOrIterateOperationAccess().getOpAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__CollectOrIterateOperation__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CollectOrIterateOperation__Group__2__Impl
+ rule__CollectOrIterateOperation__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getNameAssignment_2()); }
+(rule__CollectOrIterateOperation__NameAssignment_2)
+{ after(grammarAccess.getCollectOrIterateOperationAccess().getNameAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__CollectOrIterateOperation__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CollectOrIterateOperation__Group__3__Impl
+ rule__CollectOrIterateOperation__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getLeftParenthesisKeyword_3()); }
+
+ '('
+
+{ after(grammarAccess.getCollectOrIterateOperationAccess().getLeftParenthesisKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__CollectOrIterateOperation__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CollectOrIterateOperation__Group__4__Impl
+ rule__CollectOrIterateOperation__Group__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getExprAssignment_4()); }
+(rule__CollectOrIterateOperation__ExprAssignment_4)
+{ after(grammarAccess.getCollectOrIterateOperationAccess().getExprAssignment_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__CollectOrIterateOperation__Group__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CollectOrIterateOperation__Group__5__Impl
+ rule__CollectOrIterateOperation__Group__6
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__Group__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getRightParenthesisKeyword_5()); }
+
+ ')'
+
+{ after(grammarAccess.getCollectOrIterateOperationAccess().getRightParenthesisKeyword_5()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__CollectOrIterateOperation__Group__6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CollectOrIterateOperation__Group__6__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__Group__6__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getSuffixAssignment_6()); }
+(rule__CollectOrIterateOperation__SuffixAssignment_6)?
+{ after(grammarAccess.getCollectOrIterateOperationAccess().getSuffixAssignment_6()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__ForAllOrExistsOrOneOperation__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForAllOrExistsOrOneOperation__Group__0__Impl
+ rule__ForAllOrExistsOrOneOperation__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+
+ '->'
+
+{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForAllOrExistsOrOneOperation__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForAllOrExistsOrOneOperation__Group__1__Impl
+ rule__ForAllOrExistsOrOneOperation__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getOpAssignment_1()); }
+(rule__ForAllOrExistsOrOneOperation__OpAssignment_1)
+{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getOpAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForAllOrExistsOrOneOperation__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForAllOrExistsOrOneOperation__Group__2__Impl
+ rule__ForAllOrExistsOrOneOperation__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getNameAssignment_2()); }
+(rule__ForAllOrExistsOrOneOperation__NameAssignment_2)
+{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getNameAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForAllOrExistsOrOneOperation__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForAllOrExistsOrOneOperation__Group__3__Impl
+ rule__ForAllOrExistsOrOneOperation__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getLeftParenthesisKeyword_3()); }
+
+ '('
+
+{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getLeftParenthesisKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForAllOrExistsOrOneOperation__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForAllOrExistsOrOneOperation__Group__4__Impl
+ rule__ForAllOrExistsOrOneOperation__Group__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getExprAssignment_4()); }
+(rule__ForAllOrExistsOrOneOperation__ExprAssignment_4)
+{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getExprAssignment_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForAllOrExistsOrOneOperation__Group__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForAllOrExistsOrOneOperation__Group__5__Impl
+ rule__ForAllOrExistsOrOneOperation__Group__6
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__Group__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getRightParenthesisKeyword_5()); }
+
+ ')'
+
+{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getRightParenthesisKeyword_5()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForAllOrExistsOrOneOperation__Group__6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForAllOrExistsOrOneOperation__Group__6__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__Group__6__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getSuffixAssignment_6()); }
+(rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6)?
+{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getSuffixAssignment_6()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__IsUniqueOperation__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IsUniqueOperation__Group__0__Impl
+ rule__IsUniqueOperation__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+
+ '->'
+
+{ after(grammarAccess.getIsUniqueOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__IsUniqueOperation__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IsUniqueOperation__Group__1__Impl
+ rule__IsUniqueOperation__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getIsUniqueKeyword_1()); }
+
+ 'isUnique'
+
+{ after(grammarAccess.getIsUniqueOperationAccess().getIsUniqueKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__IsUniqueOperation__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IsUniqueOperation__Group__2__Impl
+ rule__IsUniqueOperation__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getNameAssignment_2()); }
+(rule__IsUniqueOperation__NameAssignment_2)
+{ after(grammarAccess.getIsUniqueOperationAccess().getNameAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__IsUniqueOperation__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IsUniqueOperation__Group__3__Impl
+ rule__IsUniqueOperation__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getLeftParenthesisKeyword_3()); }
+
+ '('
+
+{ after(grammarAccess.getIsUniqueOperationAccess().getLeftParenthesisKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__IsUniqueOperation__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IsUniqueOperation__Group__4__Impl
+ rule__IsUniqueOperation__Group__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getExprAssignment_4()); }
+(rule__IsUniqueOperation__ExprAssignment_4)
+{ after(grammarAccess.getIsUniqueOperationAccess().getExprAssignment_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__IsUniqueOperation__Group__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IsUniqueOperation__Group__5__Impl
+ rule__IsUniqueOperation__Group__6
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__Group__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getRightParenthesisKeyword_5()); }
+
+ ')'
+
+{ after(grammarAccess.getIsUniqueOperationAccess().getRightParenthesisKeyword_5()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__IsUniqueOperation__Group__6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IsUniqueOperation__Group__6__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__Group__6__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getSuffixAssignment_6()); }
+(rule__IsUniqueOperation__SuffixAssignment_6)?
+{ after(grammarAccess.getIsUniqueOperationAccess().getSuffixAssignment_6()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__ParenthesizedExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ParenthesizedExpression__Group__0__Impl
+ rule__ParenthesizedExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ParenthesizedExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); }
+
+ '('
+
+{ after(grammarAccess.getParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ParenthesizedExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ParenthesizedExpression__Group__1__Impl
+ rule__ParenthesizedExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ParenthesizedExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getExpOrTypeCastAssignment_1()); }
+(rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1)
+{ after(grammarAccess.getParenthesizedExpressionAccess().getExpOrTypeCastAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ParenthesizedExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ParenthesizedExpression__Group__2__Impl
+ rule__ParenthesizedExpression__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ParenthesizedExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); }
+
+ ')'
+
+{ after(grammarAccess.getParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ParenthesizedExpression__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ParenthesizedExpression__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ParenthesizedExpression__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getAlternatives_3()); }
+(rule__ParenthesizedExpression__Alternatives_3)?
+{ after(grammarAccess.getParenthesizedExpressionAccess().getAlternatives_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__NullExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NullExpression__Group__0__Impl
+ rule__NullExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NullExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNullExpressionAccess().getNullExpressionAction_0()); }
+(
+
+)
+{ after(grammarAccess.getNullExpressionAccess().getNullExpressionAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__NullExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NullExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NullExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNullExpressionAccess().getNullKeyword_1()); }
+
+ 'null'
+
+{ after(grammarAccess.getNullExpressionAccess().getNullKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ThisExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ThisExpression__Group__0__Impl
+ rule__ThisExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ThisExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getThisExpressionAccess().getThisExpressionAction_0()); }
+(
+
+)
+{ after(grammarAccess.getThisExpressionAccess().getThisExpressionAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ThisExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ThisExpression__Group__1__Impl
+ rule__ThisExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ThisExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getThisExpressionAccess().getThisKeyword_1()); }
+
+ 'this'
+
+{ after(grammarAccess.getThisExpressionAccess().getThisKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ThisExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ThisExpression__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ThisExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getThisExpressionAccess().getSuffixAssignment_2()); }
+(rule__ThisExpression__SuffixAssignment_2)?
+{ after(grammarAccess.getThisExpressionAccess().getSuffixAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__SuperInvocationExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SuperInvocationExpression__Group__0__Impl
+ rule__SuperInvocationExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getSuperKeyword_0()); }
+
+ 'super'
+
+{ after(grammarAccess.getSuperInvocationExpressionAccess().getSuperKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SuperInvocationExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SuperInvocationExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getAlternatives_1()); }
+(rule__SuperInvocationExpression__Alternatives_1)
+{ after(grammarAccess.getSuperInvocationExpressionAccess().getAlternatives_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__SuperInvocationExpression__Group_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SuperInvocationExpression__Group_1_1__0__Impl
+ rule__SuperInvocationExpression__Group_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__Group_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getFullStopKeyword_1_1_0()); }
+
+ '.'
+
+{ after(grammarAccess.getSuperInvocationExpressionAccess().getFullStopKeyword_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SuperInvocationExpression__Group_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SuperInvocationExpression__Group_1_1__1__Impl
+ rule__SuperInvocationExpression__Group_1_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__Group_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getOperationNameAssignment_1_1_1()); }
+(rule__SuperInvocationExpression__OperationNameAssignment_1_1_1)
+{ after(grammarAccess.getSuperInvocationExpressionAccess().getOperationNameAssignment_1_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SuperInvocationExpression__Group_1_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SuperInvocationExpression__Group_1_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__Group_1_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getTupleAssignment_1_1_2()); }
+(rule__SuperInvocationExpression__TupleAssignment_1_1_2)
+{ after(grammarAccess.getSuperInvocationExpressionAccess().getTupleAssignment_1_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__InstanceCreationExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InstanceCreationExpression__Group__0__Impl
+ rule__InstanceCreationExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationExpressionAccess().getNewKeyword_0()); }
+
+ 'new'
+
+{ after(grammarAccess.getInstanceCreationExpressionAccess().getNewKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InstanceCreationExpression__Group__1__Impl
+ rule__InstanceCreationExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationExpressionAccess().getConstructorAssignment_1()); }
+(rule__InstanceCreationExpression__ConstructorAssignment_1)
+{ after(grammarAccess.getInstanceCreationExpressionAccess().getConstructorAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InstanceCreationExpression__Group__2__Impl
+ rule__InstanceCreationExpression__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationExpressionAccess().getTupleAssignment_2()); }
+(rule__InstanceCreationExpression__TupleAssignment_2)
+{ after(grammarAccess.getInstanceCreationExpressionAccess().getTupleAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationExpression__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InstanceCreationExpression__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationExpression__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationExpressionAccess().getSuffixAssignment_3()); }
+(rule__InstanceCreationExpression__SuffixAssignment_3)?
+{ after(grammarAccess.getInstanceCreationExpressionAccess().getSuffixAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__InstanceCreationTuple__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InstanceCreationTuple__Group__0__Impl
+ rule__InstanceCreationTuple__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleAction_0()); }
+(
+
+)
+{ after(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationTuple__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InstanceCreationTuple__Group__1__Impl
+ rule__InstanceCreationTuple__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getLeftParenthesisKeyword_1()); }
+
+ '('
+
+{ after(grammarAccess.getInstanceCreationTupleAccess().getLeftParenthesisKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationTuple__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InstanceCreationTuple__Group__2__Impl
+ rule__InstanceCreationTuple__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getGroup_2()); }
+(rule__InstanceCreationTuple__Group_2__0)?
+{ after(grammarAccess.getInstanceCreationTupleAccess().getGroup_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationTuple__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InstanceCreationTuple__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getRightParenthesisKeyword_3()); }
+
+ ')'
+
+{ after(grammarAccess.getInstanceCreationTupleAccess().getRightParenthesisKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__InstanceCreationTuple__Group_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InstanceCreationTuple__Group_2__0__Impl
+ rule__InstanceCreationTuple__Group_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__Group_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementAssignment_2_0()); }
+(rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0)
+{ after(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementAssignment_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationTuple__Group_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InstanceCreationTuple__Group_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__Group_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getGroup_2_1()); }
+(rule__InstanceCreationTuple__Group_2_1__0)*
+{ after(grammarAccess.getInstanceCreationTupleAccess().getGroup_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__InstanceCreationTuple__Group_2_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InstanceCreationTuple__Group_2_1__0__Impl
+ rule__InstanceCreationTuple__Group_2_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__Group_2_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getCommaKeyword_2_1_0()); }
+
+ ','
+
+{ after(grammarAccess.getInstanceCreationTupleAccess().getCommaKeyword_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationTuple__Group_2_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InstanceCreationTuple__Group_2_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__Group_2_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementAssignment_2_1_1()); }
+(rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1)
+{ after(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementAssignment_2_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__InstanceCreationTupleElement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InstanceCreationTupleElement__Group__0__Impl
+ rule__InstanceCreationTupleElement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTupleElement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleElementAccess().getRoleAssignment_0()); }
+(rule__InstanceCreationTupleElement__RoleAssignment_0)
+{ after(grammarAccess.getInstanceCreationTupleElementAccess().getRoleAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationTupleElement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InstanceCreationTupleElement__Group__1__Impl
+ rule__InstanceCreationTupleElement__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTupleElement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleElementAccess().getEqualsSignGreaterThanSignKeyword_1()); }
+
+ '=>'
+
+{ after(grammarAccess.getInstanceCreationTupleElementAccess().getEqualsSignGreaterThanSignKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationTupleElement__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InstanceCreationTupleElement__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTupleElement__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleElementAccess().getObjectAssignment_2()); }
+(rule__InstanceCreationTupleElement__ObjectAssignment_2)
+{ after(grammarAccess.getInstanceCreationTupleElementAccess().getObjectAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__SequenceConstructionOrAccessCompletion__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceConstructionOrAccessCompletion__Group_0__0__Impl
+ rule__SequenceConstructionOrAccessCompletion__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionOrAccessCompletion__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorAssignment_0_0()); }
+(rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0)
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorAssignment_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SequenceConstructionOrAccessCompletion__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceConstructionOrAccessCompletion__Group_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionOrAccessCompletion__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAlternatives_0_1()); }
+(rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1)
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAlternatives_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AccessCompletion__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AccessCompletion__Group__0__Impl
+ rule__AccessCompletion__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AccessCompletion__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAccessCompletionAccess().getAccessIndexAssignment_0()); }
+(rule__AccessCompletion__AccessIndexAssignment_0)
+{ after(grammarAccess.getAccessCompletionAccess().getAccessIndexAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AccessCompletion__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AccessCompletion__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AccessCompletion__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAccessCompletionAccess().getRightSquareBracketKeyword_1()); }
+
+ ']'
+
+{ after(grammarAccess.getAccessCompletionAccess().getRightSquareBracketKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__PartialSequenceConstructionCompletion__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PartialSequenceConstructionCompletion__Group__0__Impl
+ rule__PartialSequenceConstructionCompletion__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PartialSequenceConstructionCompletion__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPartialSequenceConstructionCompletionAccess().getRightSquareBracketKeyword_0()); }
+
+ ']'
+
+{ after(grammarAccess.getPartialSequenceConstructionCompletionAccess().getRightSquareBracketKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PartialSequenceConstructionCompletion__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PartialSequenceConstructionCompletion__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PartialSequenceConstructionCompletion__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPartialSequenceConstructionCompletionAccess().getExpressionAssignment_1()); }
+(rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1)
+{ after(grammarAccess.getPartialSequenceConstructionCompletionAccess().getExpressionAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__SequenceConstructionExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceConstructionExpression__Group__0__Impl
+ rule__SequenceConstructionExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getLeftCurlyBracketKeyword_0()); }
+
+ '{'
+
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getLeftCurlyBracketKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SequenceConstructionExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceConstructionExpression__Group__1__Impl
+ rule__SequenceConstructionExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementAssignment_1()); }
+(rule__SequenceConstructionExpression__SequenceElementAssignment_1)
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SequenceConstructionExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceConstructionExpression__Group__2__Impl
+ rule__SequenceConstructionExpression__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getAlternatives_2()); }
+(rule__SequenceConstructionExpression__Alternatives_2)
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getAlternatives_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SequenceConstructionExpression__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceConstructionExpression__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getRightCurlyBracketKeyword_3()); }
+
+ '}'
+
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getRightCurlyBracketKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__SequenceConstructionExpression__Group_2_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceConstructionExpression__Group_2_0__0__Impl
+ rule__SequenceConstructionExpression__Group_2_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Group_2_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getCommaKeyword_2_0_0()); }
+
+ ','
+
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getCommaKeyword_2_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SequenceConstructionExpression__Group_2_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceConstructionExpression__Group_2_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Group_2_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementAssignment_2_0_1()); }
+(rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1)
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementAssignment_2_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__SequenceConstructionExpression__Group_2_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceConstructionExpression__Group_2_1__0__Impl
+ rule__SequenceConstructionExpression__Group_2_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Group_2_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getFullStopFullStopKeyword_2_1_0()); }
+
+ '..'
+
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getFullStopFullStopKeyword_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SequenceConstructionExpression__Group_2_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequenceConstructionExpression__Group_2_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Group_2_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getRangeUpperAssignment_2_1_1()); }
+(rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1)
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getRangeUpperAssignment_2_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ClassExtentExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassExtentExpression__Group__0__Impl
+ rule__ClassExtentExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassExtentExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassExtentExpressionAccess().getClassExtentExpressionAction_0()); }
+(
+
+)
+{ after(grammarAccess.getClassExtentExpressionAccess().getClassExtentExpressionAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassExtentExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassExtentExpression__Group__1__Impl
+ rule__ClassExtentExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassExtentExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassExtentExpressionAccess().getFullStopKeyword_1()); }
+
+ '.'
+
+{ after(grammarAccess.getClassExtentExpressionAccess().getFullStopKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassExtentExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassExtentExpression__Group__2__Impl
+ rule__ClassExtentExpression__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassExtentExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassExtentExpressionAccess().getAllInstancesKeyword_2()); }
+
+ 'allInstances'
+
+{ after(grammarAccess.getClassExtentExpressionAccess().getAllInstancesKeyword_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassExtentExpression__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassExtentExpression__Group__3__Impl
+ rule__ClassExtentExpression__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassExtentExpression__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassExtentExpressionAccess().getLeftParenthesisKeyword_3()); }
+
+ '('
+
+{ after(grammarAccess.getClassExtentExpressionAccess().getLeftParenthesisKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassExtentExpression__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassExtentExpression__Group__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassExtentExpression__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassExtentExpressionAccess().getRightParenthesisKeyword_4()); }
+
+ ')'
+
+{ after(grammarAccess.getClassExtentExpressionAccess().getRightParenthesisKeyword_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__Block__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Block__Group__0__Impl
+ rule__Block__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Block__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBlockAccess().getLeftCurlyBracketKeyword_0()); }
+
+ '{'
+
+{ after(grammarAccess.getBlockAccess().getLeftCurlyBracketKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Block__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Block__Group__1__Impl
+ rule__Block__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Block__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBlockAccess().getBlockAction_1()); }
+(
+
+)
+{ after(grammarAccess.getBlockAccess().getBlockAction_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Block__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Block__Group__2__Impl
+ rule__Block__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Block__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBlockAccess().getSequenceAssignment_2()); }
+(rule__Block__SequenceAssignment_2)?
+{ after(grammarAccess.getBlockAccess().getSequenceAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Block__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Block__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Block__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBlockAccess().getRightCurlyBracketKeyword_3()); }
+
+ '}'
+
+{ after(grammarAccess.getBlockAccess().getRightCurlyBracketKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__DocumentedStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DocumentedStatement__Group__0__Impl
+ rule__DocumentedStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DocumentedStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDocumentedStatementAccess().getCommentAssignment_0()); }
+(rule__DocumentedStatement__CommentAssignment_0)?
+{ after(grammarAccess.getDocumentedStatementAccess().getCommentAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DocumentedStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DocumentedStatement__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DocumentedStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDocumentedStatementAccess().getStatementAssignment_1()); }
+(rule__DocumentedStatement__StatementAssignment_1)
+{ after(grammarAccess.getDocumentedStatementAccess().getStatementAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__InlineStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InlineStatement__Group__0__Impl
+ rule__InlineStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getSolidusAsteriskCommercialAtKeyword_0()); }
+
+ '/*@'
+
+{ after(grammarAccess.getInlineStatementAccess().getSolidusAsteriskCommercialAtKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InlineStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InlineStatement__Group__1__Impl
+ rule__InlineStatement__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getInlineKeyword_1()); }
+
+ 'inline'
+
+{ after(grammarAccess.getInlineStatementAccess().getInlineKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InlineStatement__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InlineStatement__Group__2__Impl
+ rule__InlineStatement__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getLeftParenthesisKeyword_2()); }
+
+ '('
+
+{ after(grammarAccess.getInlineStatementAccess().getLeftParenthesisKeyword_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InlineStatement__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InlineStatement__Group__3__Impl
+ rule__InlineStatement__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getLangageNameAssignment_3()); }
+(rule__InlineStatement__LangageNameAssignment_3)
+{ after(grammarAccess.getInlineStatementAccess().getLangageNameAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InlineStatement__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InlineStatement__Group__4__Impl
+ rule__InlineStatement__Group__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getRightParenthesisKeyword_4()); }
+
+ ')'
+
+{ after(grammarAccess.getInlineStatementAccess().getRightParenthesisKeyword_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InlineStatement__Group__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InlineStatement__Group__5__Impl
+ rule__InlineStatement__Group__6
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__Group__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getBodyAssignment_5()); }
+(rule__InlineStatement__BodyAssignment_5)
+{ after(grammarAccess.getInlineStatementAccess().getBodyAssignment_5()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InlineStatement__Group__6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InlineStatement__Group__6__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__Group__6__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getAsteriskSolidusKeyword_6()); }
+
+ '*/'
+
+{ after(grammarAccess.getInlineStatementAccess().getAsteriskSolidusKeyword_6()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__AnnotatedStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AnnotatedStatement__Group__0__Impl
+ rule__AnnotatedStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AnnotatedStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotatedStatementAccess().getSolidusSolidusCommercialAtKeyword_0()); }
+
+ '//@'
+
+{ after(grammarAccess.getAnnotatedStatementAccess().getSolidusSolidusCommercialAtKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AnnotatedStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AnnotatedStatement__Group__1__Impl
+ rule__AnnotatedStatement__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AnnotatedStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotatedStatementAccess().getAnnotationAssignment_1()); }
+(rule__AnnotatedStatement__AnnotationAssignment_1)
+{ after(grammarAccess.getAnnotatedStatementAccess().getAnnotationAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AnnotatedStatement__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AnnotatedStatement__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AnnotatedStatement__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotatedStatementAccess().getStatementAssignment_2()); }
+(rule__AnnotatedStatement__StatementAssignment_2)
+{ after(grammarAccess.getAnnotatedStatementAccess().getStatementAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__Annotation__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Annotation__Group__0__Impl
+ rule__Annotation__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Annotation__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getKindAssignment_0()); }
+(rule__Annotation__KindAssignment_0)
+{ after(grammarAccess.getAnnotationAccess().getKindAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Annotation__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Annotation__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Annotation__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getGroup_1()); }
+(rule__Annotation__Group_1__0)?
+{ after(grammarAccess.getAnnotationAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Annotation__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Annotation__Group_1__0__Impl
+ rule__Annotation__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Annotation__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getLeftParenthesisKeyword_1_0()); }
+
+ '('
+
+{ after(grammarAccess.getAnnotationAccess().getLeftParenthesisKeyword_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Annotation__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Annotation__Group_1__1__Impl
+ rule__Annotation__Group_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Annotation__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getArgsAssignment_1_1()); }
+(rule__Annotation__ArgsAssignment_1_1)
+{ after(grammarAccess.getAnnotationAccess().getArgsAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Annotation__Group_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Annotation__Group_1__2__Impl
+ rule__Annotation__Group_1__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Annotation__Group_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getGroup_1_2()); }
+(rule__Annotation__Group_1_2__0)*
+{ after(grammarAccess.getAnnotationAccess().getGroup_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Annotation__Group_1__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Annotation__Group_1__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Annotation__Group_1__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getRightParenthesisKeyword_1_3()); }
+
+ ')'
+
+{ after(grammarAccess.getAnnotationAccess().getRightParenthesisKeyword_1_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__Annotation__Group_1_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Annotation__Group_1_2__0__Impl
+ rule__Annotation__Group_1_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Annotation__Group_1_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getCommaKeyword_1_2_0()); }
+
+ ','
+
+{ after(grammarAccess.getAnnotationAccess().getCommaKeyword_1_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Annotation__Group_1_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Annotation__Group_1_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Annotation__Group_1_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getArgsAssignment_1_2_1()); }
+(rule__Annotation__ArgsAssignment_1_2_1)
+{ after(grammarAccess.getAnnotationAccess().getArgsAssignment_1_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__EmptyStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__EmptyStatement__Group__0__Impl
+ rule__EmptyStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__EmptyStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getEmptyStatementAccess().getEmptyStatementAction_0()); }
+(
+
+)
+{ after(grammarAccess.getEmptyStatementAccess().getEmptyStatementAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__EmptyStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__EmptyStatement__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__EmptyStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getEmptyStatementAccess().getSemicolonKeyword_1()); }
+
+ ';'
+
+{ after(grammarAccess.getEmptyStatementAccess().getSemicolonKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__LocalNameDeclarationStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LocalNameDeclarationStatement__Group__0__Impl
+ rule__LocalNameDeclarationStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getLetKeyword_0()); }
+
+ 'let'
+
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getLetKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LocalNameDeclarationStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LocalNameDeclarationStatement__Group__1__Impl
+ rule__LocalNameDeclarationStatement__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getVarNameAssignment_1()); }
+(rule__LocalNameDeclarationStatement__VarNameAssignment_1)
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getVarNameAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LocalNameDeclarationStatement__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LocalNameDeclarationStatement__Group__2__Impl
+ rule__LocalNameDeclarationStatement__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getColonKeyword_2()); }
+
+ ':'
+
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getColonKeyword_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LocalNameDeclarationStatement__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LocalNameDeclarationStatement__Group__3__Impl
+ rule__LocalNameDeclarationStatement__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getTypeAssignment_3()); }
+(rule__LocalNameDeclarationStatement__TypeAssignment_3)
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getTypeAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LocalNameDeclarationStatement__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LocalNameDeclarationStatement__Group__4__Impl
+ rule__LocalNameDeclarationStatement__Group__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getGroup_4()); }
+(rule__LocalNameDeclarationStatement__Group_4__0)?
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getGroup_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LocalNameDeclarationStatement__Group__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LocalNameDeclarationStatement__Group__5__Impl
+ rule__LocalNameDeclarationStatement__Group__6
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getEqualsSignKeyword_5()); }
+
+ '='
+
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getEqualsSignKeyword_5()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LocalNameDeclarationStatement__Group__6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LocalNameDeclarationStatement__Group__6__Impl
+ rule__LocalNameDeclarationStatement__Group__7
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group__6__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getInitAssignment_6()); }
+(rule__LocalNameDeclarationStatement__InitAssignment_6)
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getInitAssignment_6()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LocalNameDeclarationStatement__Group__7
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LocalNameDeclarationStatement__Group__7__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group__7__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getSemicolonKeyword_7()); }
+
+ ';'
+
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getSemicolonKeyword_7()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__LocalNameDeclarationStatement__Group_4__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LocalNameDeclarationStatement__Group_4__0__Impl
+ rule__LocalNameDeclarationStatement__Group_4__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group_4__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorAssignment_4_0()); }
+(rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0)
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorAssignment_4_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LocalNameDeclarationStatement__Group_4__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LocalNameDeclarationStatement__Group_4__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group_4__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getRightSquareBracketKeyword_4_1()); }
+
+ ']'
+
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getRightSquareBracketKeyword_4_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__IfStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IfStatement__Group__0__Impl
+ rule__IfStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IfStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIfStatementAccess().getIfKeyword_0()); }
+
+ 'if'
+
+{ after(grammarAccess.getIfStatementAccess().getIfKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__IfStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IfStatement__Group__1__Impl
+ rule__IfStatement__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IfStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIfStatementAccess().getSequentialClaussesAssignment_1()); }
+(rule__IfStatement__SequentialClaussesAssignment_1)
+{ after(grammarAccess.getIfStatementAccess().getSequentialClaussesAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__IfStatement__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IfStatement__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IfStatement__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIfStatementAccess().getFinalClauseAssignment_2()); }
+(rule__IfStatement__FinalClauseAssignment_2)?
+{ after(grammarAccess.getIfStatementAccess().getFinalClauseAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__SequentialClauses__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequentialClauses__Group__0__Impl
+ rule__SequentialClauses__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequentialClauses__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequentialClausesAccess().getConccurentClausesAssignment_0()); }
+(rule__SequentialClauses__ConccurentClausesAssignment_0)
+{ after(grammarAccess.getSequentialClausesAccess().getConccurentClausesAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SequentialClauses__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequentialClauses__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequentialClauses__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequentialClausesAccess().getGroup_1()); }
+(rule__SequentialClauses__Group_1__0)*
+{ after(grammarAccess.getSequentialClausesAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__SequentialClauses__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequentialClauses__Group_1__0__Impl
+ rule__SequentialClauses__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequentialClauses__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequentialClausesAccess().getElseKeyword_1_0()); }
+
+ 'else'
+
+{ after(grammarAccess.getSequentialClausesAccess().getElseKeyword_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SequentialClauses__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequentialClauses__Group_1__1__Impl
+ rule__SequentialClauses__Group_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequentialClauses__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequentialClausesAccess().getIfKeyword_1_1()); }
+
+ 'if'
+
+{ after(grammarAccess.getSequentialClausesAccess().getIfKeyword_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SequentialClauses__Group_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SequentialClauses__Group_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequentialClauses__Group_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequentialClausesAccess().getConccurentClausesAssignment_1_2()); }
+(rule__SequentialClauses__ConccurentClausesAssignment_1_2)
+{ after(grammarAccess.getSequentialClausesAccess().getConccurentClausesAssignment_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__ConcurrentClauses__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConcurrentClauses__Group__0__Impl
+ rule__ConcurrentClauses__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConcurrentClauses__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseAssignment_0()); }
+(rule__ConcurrentClauses__NonFinalClauseAssignment_0)
+{ after(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ConcurrentClauses__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConcurrentClauses__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConcurrentClauses__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConcurrentClausesAccess().getGroup_1()); }
+(rule__ConcurrentClauses__Group_1__0)*
+{ after(grammarAccess.getConcurrentClausesAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ConcurrentClauses__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConcurrentClauses__Group_1__0__Impl
+ rule__ConcurrentClauses__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConcurrentClauses__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConcurrentClausesAccess().getOrKeyword_1_0()); }
+
+ 'or'
+
+{ after(grammarAccess.getConcurrentClausesAccess().getOrKeyword_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ConcurrentClauses__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConcurrentClauses__Group_1__1__Impl
+ rule__ConcurrentClauses__Group_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConcurrentClauses__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConcurrentClausesAccess().getIfKeyword_1_1()); }
+
+ 'if'
+
+{ after(grammarAccess.getConcurrentClausesAccess().getIfKeyword_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ConcurrentClauses__Group_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ConcurrentClauses__Group_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConcurrentClauses__Group_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseAssignment_1_2()); }
+(rule__ConcurrentClauses__NonFinalClauseAssignment_1_2)
+{ after(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseAssignment_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__NonFinalClause__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NonFinalClause__Group__0__Impl
+ rule__NonFinalClause__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NonFinalClause__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNonFinalClauseAccess().getLeftParenthesisKeyword_0()); }
+
+ '('
+
+{ after(grammarAccess.getNonFinalClauseAccess().getLeftParenthesisKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__NonFinalClause__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NonFinalClause__Group__1__Impl
+ rule__NonFinalClause__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NonFinalClause__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNonFinalClauseAccess().getConditionAssignment_1()); }
+(rule__NonFinalClause__ConditionAssignment_1)
+{ after(grammarAccess.getNonFinalClauseAccess().getConditionAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__NonFinalClause__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NonFinalClause__Group__2__Impl
+ rule__NonFinalClause__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NonFinalClause__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNonFinalClauseAccess().getRightParenthesisKeyword_2()); }
+
+ ')'
+
+{ after(grammarAccess.getNonFinalClauseAccess().getRightParenthesisKeyword_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__NonFinalClause__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NonFinalClause__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NonFinalClause__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNonFinalClauseAccess().getBlockAssignment_3()); }
+(rule__NonFinalClause__BlockAssignment_3)
+{ after(grammarAccess.getNonFinalClauseAccess().getBlockAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__FinalClause__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__FinalClause__Group__0__Impl
+ rule__FinalClause__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__FinalClause__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getFinalClauseAccess().getElseKeyword_0()); }
+
+ 'else'
+
+{ after(grammarAccess.getFinalClauseAccess().getElseKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__FinalClause__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__FinalClause__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__FinalClause__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getFinalClauseAccess().getBlockAssignment_1()); }
+(rule__FinalClause__BlockAssignment_1)
+{ after(grammarAccess.getFinalClauseAccess().getBlockAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__SwitchStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SwitchStatement__Group__0__Impl
+ rule__SwitchStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getSwitchKeyword_0()); }
+
+ 'switch'
+
+{ after(grammarAccess.getSwitchStatementAccess().getSwitchKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SwitchStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SwitchStatement__Group__1__Impl
+ rule__SwitchStatement__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getLeftParenthesisKeyword_1()); }
+
+ '('
+
+{ after(grammarAccess.getSwitchStatementAccess().getLeftParenthesisKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SwitchStatement__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SwitchStatement__Group__2__Impl
+ rule__SwitchStatement__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getExpressionAssignment_2()); }
+(rule__SwitchStatement__ExpressionAssignment_2)
+{ after(grammarAccess.getSwitchStatementAccess().getExpressionAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SwitchStatement__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SwitchStatement__Group__3__Impl
+ rule__SwitchStatement__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getRightParenthesisKeyword_3()); }
+
+ ')'
+
+{ after(grammarAccess.getSwitchStatementAccess().getRightParenthesisKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SwitchStatement__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SwitchStatement__Group__4__Impl
+ rule__SwitchStatement__Group__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getLeftCurlyBracketKeyword_4()); }
+
+ '{'
+
+{ after(grammarAccess.getSwitchStatementAccess().getLeftCurlyBracketKeyword_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SwitchStatement__Group__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SwitchStatement__Group__5__Impl
+ rule__SwitchStatement__Group__6
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__Group__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getSwitchClauseAssignment_5()); }
+(rule__SwitchStatement__SwitchClauseAssignment_5)*
+{ after(grammarAccess.getSwitchStatementAccess().getSwitchClauseAssignment_5()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SwitchStatement__Group__6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SwitchStatement__Group__6__Impl
+ rule__SwitchStatement__Group__7
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__Group__6__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getDefaultClauseAssignment_6()); }
+(rule__SwitchStatement__DefaultClauseAssignment_6)?
+{ after(grammarAccess.getSwitchStatementAccess().getDefaultClauseAssignment_6()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SwitchStatement__Group__7
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SwitchStatement__Group__7__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__Group__7__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getRightCurlyBracketKeyword_7()); }
+
+ '}'
+
+{ after(grammarAccess.getSwitchStatementAccess().getRightCurlyBracketKeyword_7()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__SwitchClause__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SwitchClause__Group__0__Impl
+ rule__SwitchClause__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchClause__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchClauseAccess().getSwitchCaseAssignment_0()); }
+(rule__SwitchClause__SwitchCaseAssignment_0)
+{ after(grammarAccess.getSwitchClauseAccess().getSwitchCaseAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SwitchClause__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SwitchClause__Group__1__Impl
+ rule__SwitchClause__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchClause__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchClauseAccess().getSwitchCaseAssignment_1()); }
+(rule__SwitchClause__SwitchCaseAssignment_1)*
+{ after(grammarAccess.getSwitchClauseAccess().getSwitchCaseAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SwitchClause__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SwitchClause__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchClause__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchClauseAccess().getStatementSequenceAssignment_2()); }
+(rule__SwitchClause__StatementSequenceAssignment_2)
+{ after(grammarAccess.getSwitchClauseAccess().getStatementSequenceAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__SwitchCase__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SwitchCase__Group__0__Impl
+ rule__SwitchCase__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchCase__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchCaseAccess().getCaseKeyword_0()); }
+
+ 'case'
+
+{ after(grammarAccess.getSwitchCaseAccess().getCaseKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SwitchCase__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SwitchCase__Group__1__Impl
+ rule__SwitchCase__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchCase__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchCaseAccess().getExpressionAssignment_1()); }
+(rule__SwitchCase__ExpressionAssignment_1)
+{ after(grammarAccess.getSwitchCaseAccess().getExpressionAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SwitchCase__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SwitchCase__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchCase__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchCaseAccess().getColonKeyword_2()); }
+
+ ':'
+
+{ after(grammarAccess.getSwitchCaseAccess().getColonKeyword_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__SwitchDefaultClause__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SwitchDefaultClause__Group__0__Impl
+ rule__SwitchDefaultClause__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchDefaultClause__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchDefaultClauseAccess().getDefaultKeyword_0()); }
+
+ 'default'
+
+{ after(grammarAccess.getSwitchDefaultClauseAccess().getDefaultKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SwitchDefaultClause__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SwitchDefaultClause__Group__1__Impl
+ rule__SwitchDefaultClause__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchDefaultClause__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchDefaultClauseAccess().getColonKeyword_1()); }
+
+ ':'
+
+{ after(grammarAccess.getSwitchDefaultClauseAccess().getColonKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SwitchDefaultClause__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SwitchDefaultClause__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchDefaultClause__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchDefaultClauseAccess().getStatementSequenceAssignment_2()); }
+(rule__SwitchDefaultClause__StatementSequenceAssignment_2)
+{ after(grammarAccess.getSwitchDefaultClauseAccess().getStatementSequenceAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__WhileStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__WhileStatement__Group__0__Impl
+ rule__WhileStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__WhileStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getWhileStatementAccess().getWhileKeyword_0()); }
+
+ 'while'
+
+{ after(grammarAccess.getWhileStatementAccess().getWhileKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__WhileStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__WhileStatement__Group__1__Impl
+ rule__WhileStatement__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__WhileStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getWhileStatementAccess().getLeftParenthesisKeyword_1()); }
+
+ '('
+
+{ after(grammarAccess.getWhileStatementAccess().getLeftParenthesisKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__WhileStatement__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__WhileStatement__Group__2__Impl
+ rule__WhileStatement__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__WhileStatement__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getWhileStatementAccess().getConditionAssignment_2()); }
+(rule__WhileStatement__ConditionAssignment_2)
+{ after(grammarAccess.getWhileStatementAccess().getConditionAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__WhileStatement__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__WhileStatement__Group__3__Impl
+ rule__WhileStatement__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__WhileStatement__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getWhileStatementAccess().getRightParenthesisKeyword_3()); }
+
+ ')'
+
+{ after(grammarAccess.getWhileStatementAccess().getRightParenthesisKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__WhileStatement__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__WhileStatement__Group__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__WhileStatement__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getWhileStatementAccess().getBlockAssignment_4()); }
+(rule__WhileStatement__BlockAssignment_4)
+{ after(grammarAccess.getWhileStatementAccess().getBlockAssignment_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__DoStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DoStatement__Group__0__Impl
+ rule__DoStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DoStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getDoKeyword_0()); }
+
+ 'do'
+
+{ after(grammarAccess.getDoStatementAccess().getDoKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DoStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DoStatement__Group__1__Impl
+ rule__DoStatement__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DoStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getBlockAssignment_1()); }
+(rule__DoStatement__BlockAssignment_1)
+{ after(grammarAccess.getDoStatementAccess().getBlockAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DoStatement__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DoStatement__Group__2__Impl
+ rule__DoStatement__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DoStatement__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getWhileKeyword_2()); }
+
+ 'while'
+
+{ after(grammarAccess.getDoStatementAccess().getWhileKeyword_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DoStatement__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DoStatement__Group__3__Impl
+ rule__DoStatement__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DoStatement__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getLeftParenthesisKeyword_3()); }
+
+ '('
+
+{ after(grammarAccess.getDoStatementAccess().getLeftParenthesisKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DoStatement__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DoStatement__Group__4__Impl
+ rule__DoStatement__Group__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DoStatement__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getConditionAssignment_4()); }
+(rule__DoStatement__ConditionAssignment_4)
+{ after(grammarAccess.getDoStatementAccess().getConditionAssignment_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DoStatement__Group__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DoStatement__Group__5__Impl
+ rule__DoStatement__Group__6
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DoStatement__Group__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getRightParenthesisKeyword_5()); }
+
+ ')'
+
+{ after(grammarAccess.getDoStatementAccess().getRightParenthesisKeyword_5()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DoStatement__Group__6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DoStatement__Group__6__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DoStatement__Group__6__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getSemicolonKeyword_6()); }
+
+ ';'
+
+{ after(grammarAccess.getDoStatementAccess().getSemicolonKeyword_6()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__ForStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForStatement__Group__0__Impl
+ rule__ForStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForStatementAccess().getForKeyword_0()); }
+
+ 'for'
+
+{ after(grammarAccess.getForStatementAccess().getForKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForStatement__Group__1__Impl
+ rule__ForStatement__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForStatementAccess().getLeftParenthesisKeyword_1()); }
+
+ '('
+
+{ after(grammarAccess.getForStatementAccess().getLeftParenthesisKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForStatement__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForStatement__Group__2__Impl
+ rule__ForStatement__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForStatement__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForStatementAccess().getControlAssignment_2()); }
+(rule__ForStatement__ControlAssignment_2)
+{ after(grammarAccess.getForStatementAccess().getControlAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForStatement__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForStatement__Group__3__Impl
+ rule__ForStatement__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForStatement__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForStatementAccess().getRightParenthesisKeyword_3()); }
+
+ ')'
+
+{ after(grammarAccess.getForStatementAccess().getRightParenthesisKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForStatement__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForStatement__Group__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForStatement__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForStatementAccess().getBlockAssignment_4()); }
+(rule__ForStatement__BlockAssignment_4)
+{ after(grammarAccess.getForStatementAccess().getBlockAssignment_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__ForControl__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForControl__Group__0__Impl
+ rule__ForControl__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForControl__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForControlAccess().getLoopVariableDefinitionAssignment_0()); }
+(rule__ForControl__LoopVariableDefinitionAssignment_0)
+{ after(grammarAccess.getForControlAccess().getLoopVariableDefinitionAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForControl__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForControl__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForControl__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForControlAccess().getGroup_1()); }
+(rule__ForControl__Group_1__0)*
+{ after(grammarAccess.getForControlAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ForControl__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForControl__Group_1__0__Impl
+ rule__ForControl__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForControl__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForControlAccess().getCommaKeyword_1_0()); }
+
+ ','
+
+{ after(grammarAccess.getForControlAccess().getCommaKeyword_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForControl__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForControl__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForControl__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForControlAccess().getLoopVariableDefinitionAssignment_1_1()); }
+(rule__ForControl__LoopVariableDefinitionAssignment_1_1)
+{ after(grammarAccess.getForControlAccess().getLoopVariableDefinitionAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__LoopVariableDefinition__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LoopVariableDefinition__Group_0__0__Impl
+ rule__LoopVariableDefinition__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getNameAssignment_0_0()); }
+(rule__LoopVariableDefinition__NameAssignment_0_0)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getNameAssignment_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LoopVariableDefinition__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LoopVariableDefinition__Group_0__1__Impl
+ rule__LoopVariableDefinition__Group_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getInKeyword_0_1()); }
+
+ 'in'
+
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getInKeyword_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LoopVariableDefinition__Group_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LoopVariableDefinition__Group_0__2__Impl
+ rule__LoopVariableDefinition__Group_0__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getExpression1Assignment_0_2()); }
+(rule__LoopVariableDefinition__Expression1Assignment_0_2)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getExpression1Assignment_0_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LoopVariableDefinition__Group_0__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LoopVariableDefinition__Group_0__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_0__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getGroup_0_3()); }
+(rule__LoopVariableDefinition__Group_0_3__0)?
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getGroup_0_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__LoopVariableDefinition__Group_0_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LoopVariableDefinition__Group_0_3__0__Impl
+ rule__LoopVariableDefinition__Group_0_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_0_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getFullStopFullStopKeyword_0_3_0()); }
+
+ '..'
+
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getFullStopFullStopKeyword_0_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LoopVariableDefinition__Group_0_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LoopVariableDefinition__Group_0_3__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_0_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getExpression2Assignment_0_3_1()); }
+(rule__LoopVariableDefinition__Expression2Assignment_0_3_1)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getExpression2Assignment_0_3_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__LoopVariableDefinition__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LoopVariableDefinition__Group_1__0__Impl
+ rule__LoopVariableDefinition__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getTypeAssignment_1_0()); }
+(rule__LoopVariableDefinition__TypeAssignment_1_0)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getTypeAssignment_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LoopVariableDefinition__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LoopVariableDefinition__Group_1__1__Impl
+ rule__LoopVariableDefinition__Group_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getNameAssignment_1_1()); }
+(rule__LoopVariableDefinition__NameAssignment_1_1)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getNameAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LoopVariableDefinition__Group_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LoopVariableDefinition__Group_1__2__Impl
+ rule__LoopVariableDefinition__Group_1__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getColonKeyword_1_2()); }
+
+ ':'
+
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getColonKeyword_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LoopVariableDefinition__Group_1__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LoopVariableDefinition__Group_1__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_1__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getExpressionAssignment_1_3()); }
+(rule__LoopVariableDefinition__ExpressionAssignment_1_3)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getExpressionAssignment_1_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__BreakStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__BreakStatement__Group__0__Impl
+ rule__BreakStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__BreakStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBreakStatementAccess().getBreakStatementAction_0()); }
+(
+
+)
+{ after(grammarAccess.getBreakStatementAccess().getBreakStatementAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__BreakStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__BreakStatement__Group__1__Impl
+ rule__BreakStatement__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__BreakStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBreakStatementAccess().getBreakKeyword_1()); }
+
+ 'break'
+
+{ after(grammarAccess.getBreakStatementAccess().getBreakKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__BreakStatement__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__BreakStatement__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__BreakStatement__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBreakStatementAccess().getSemicolonKeyword_2()); }
+
+ ';'
+
+{ after(grammarAccess.getBreakStatementAccess().getSemicolonKeyword_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__ReturnStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ReturnStatement__Group__0__Impl
+ rule__ReturnStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ReturnStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getReturnStatementAccess().getReturnKeyword_0()); }
+
+ 'return'
+
+{ after(grammarAccess.getReturnStatementAccess().getReturnKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ReturnStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ReturnStatement__Group__1__Impl
+ rule__ReturnStatement__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ReturnStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getReturnStatementAccess().getExpressionAssignment_1()); }
+(rule__ReturnStatement__ExpressionAssignment_1)
+{ after(grammarAccess.getReturnStatementAccess().getExpressionAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ReturnStatement__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ReturnStatement__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ReturnStatement__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getReturnStatementAccess().getSemicolonKeyword_2()); }
+
+ ';'
+
+{ after(grammarAccess.getReturnStatementAccess().getSemicolonKeyword_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__AcceptStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AcceptStatement__Group__0__Impl
+ rule__AcceptStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptStatementAccess().getClauseAssignment_0()); }
+(rule__AcceptStatement__ClauseAssignment_0)
+{ after(grammarAccess.getAcceptStatementAccess().getClauseAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AcceptStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AcceptStatement__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptStatementAccess().getAlternatives_1()); }
+(rule__AcceptStatement__Alternatives_1)
+{ after(grammarAccess.getAcceptStatementAccess().getAlternatives_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__SimpleAcceptStatementCompletion__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SimpleAcceptStatementCompletion__Group__0__Impl
+ rule__SimpleAcceptStatementCompletion__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SimpleAcceptStatementCompletion__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSimpleAcceptStatementCompletionAccess().getSimpleAcceptStatementCompletionAction_0()); }
+(
+
+)
+{ after(grammarAccess.getSimpleAcceptStatementCompletionAccess().getSimpleAcceptStatementCompletionAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SimpleAcceptStatementCompletion__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SimpleAcceptStatementCompletion__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SimpleAcceptStatementCompletion__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSimpleAcceptStatementCompletionAccess().getSemicolonKeyword_1()); }
+
+ ';'
+
+{ after(grammarAccess.getSimpleAcceptStatementCompletionAccess().getSemicolonKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__CompoundAcceptStatementCompletion__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CompoundAcceptStatementCompletion__Group__0__Impl
+ rule__CompoundAcceptStatementCompletion__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CompoundAcceptStatementCompletion__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getBlockAssignment_0()); }
+(rule__CompoundAcceptStatementCompletion__BlockAssignment_0)
+{ after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getBlockAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__CompoundAcceptStatementCompletion__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CompoundAcceptStatementCompletion__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CompoundAcceptStatementCompletion__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getGroup_1()); }
+(rule__CompoundAcceptStatementCompletion__Group_1__0)*
+{ after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__CompoundAcceptStatementCompletion__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CompoundAcceptStatementCompletion__Group_1__0__Impl
+ rule__CompoundAcceptStatementCompletion__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CompoundAcceptStatementCompletion__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getOrKeyword_1_0()); }
+
+ 'or'
+
+{ after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getOrKeyword_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__CompoundAcceptStatementCompletion__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CompoundAcceptStatementCompletion__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CompoundAcceptStatementCompletion__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getAcceptBlockAssignment_1_1()); }
+(rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1)
+{ after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getAcceptBlockAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AcceptBlock__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AcceptBlock__Group__0__Impl
+ rule__AcceptBlock__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptBlock__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptBlockAccess().getClauseAssignment_0()); }
+(rule__AcceptBlock__ClauseAssignment_0)
+{ after(grammarAccess.getAcceptBlockAccess().getClauseAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AcceptBlock__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AcceptBlock__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptBlock__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptBlockAccess().getBlockAssignment_1()); }
+(rule__AcceptBlock__BlockAssignment_1)
+{ after(grammarAccess.getAcceptBlockAccess().getBlockAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AcceptClause__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AcceptClause__Group__0__Impl
+ rule__AcceptClause__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getAcceptKeyword_0()); }
+
+ 'accept'
+
+{ after(grammarAccess.getAcceptClauseAccess().getAcceptKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AcceptClause__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AcceptClause__Group__1__Impl
+ rule__AcceptClause__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getLeftParenthesisKeyword_1()); }
+
+ '('
+
+{ after(grammarAccess.getAcceptClauseAccess().getLeftParenthesisKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AcceptClause__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AcceptClause__Group__2__Impl
+ rule__AcceptClause__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getGroup_2()); }
+(rule__AcceptClause__Group_2__0)?
+{ after(grammarAccess.getAcceptClauseAccess().getGroup_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AcceptClause__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AcceptClause__Group__3__Impl
+ rule__AcceptClause__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getQualifiedNameListAssignment_3()); }
+(rule__AcceptClause__QualifiedNameListAssignment_3)
+{ after(grammarAccess.getAcceptClauseAccess().getQualifiedNameListAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AcceptClause__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AcceptClause__Group__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getRightParenthesisKeyword_4()); }
+
+ ')'
+
+{ after(grammarAccess.getAcceptClauseAccess().getRightParenthesisKeyword_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__AcceptClause__Group_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AcceptClause__Group_2__0__Impl
+ rule__AcceptClause__Group_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__Group_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getNameAssignment_2_0()); }
+(rule__AcceptClause__NameAssignment_2_0)
+{ after(grammarAccess.getAcceptClauseAccess().getNameAssignment_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AcceptClause__Group_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AcceptClause__Group_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__Group_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getColonKeyword_2_1()); }
+
+ ':'
+
+{ after(grammarAccess.getAcceptClauseAccess().getColonKeyword_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ClassifyStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassifyStatement__Group__0__Impl
+ rule__ClassifyStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassifyStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassifyStatementAccess().getClassifyKeyword_0()); }
+
+ 'classify'
+
+{ after(grammarAccess.getClassifyStatementAccess().getClassifyKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassifyStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassifyStatement__Group__1__Impl
+ rule__ClassifyStatement__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassifyStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassifyStatementAccess().getExpressionAssignment_1()); }
+(rule__ClassifyStatement__ExpressionAssignment_1)
+{ after(grammarAccess.getClassifyStatementAccess().getExpressionAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassifyStatement__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassifyStatement__Group__2__Impl
+ rule__ClassifyStatement__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassifyStatement__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassifyStatementAccess().getClauseAssignment_2()); }
+(rule__ClassifyStatement__ClauseAssignment_2)
+{ after(grammarAccess.getClassifyStatementAccess().getClauseAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassifyStatement__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassifyStatement__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassifyStatement__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassifyStatementAccess().getSemicolonKeyword_3()); }
+
+ ';'
+
+{ after(grammarAccess.getClassifyStatementAccess().getSemicolonKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__ClassificationClause__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassificationClause__Group_0__0__Impl
+ rule__ClassificationClause__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getClassifyFromClauseAssignment_0_0()); }
+(rule__ClassificationClause__ClassifyFromClauseAssignment_0_0)
+{ after(grammarAccess.getClassificationClauseAccess().getClassifyFromClauseAssignment_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassificationClause__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassificationClause__Group_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getClassifyToClauseAssignment_0_1()); }
+(rule__ClassificationClause__ClassifyToClauseAssignment_0_1)?
+{ after(grammarAccess.getClassificationClauseAccess().getClassifyToClauseAssignment_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ClassificationClause__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassificationClause__Group_1__0__Impl
+ rule__ClassificationClause__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getReclassyAllClauseAssignment_1_0()); }
+(rule__ClassificationClause__ReclassyAllClauseAssignment_1_0)?
+{ after(grammarAccess.getClassificationClauseAccess().getReclassyAllClauseAssignment_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassificationClause__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassificationClause__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getClassifyToClauseAssignment_1_1()); }
+(rule__ClassificationClause__ClassifyToClauseAssignment_1_1)
+{ after(grammarAccess.getClassificationClauseAccess().getClassifyToClauseAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ClassificationFromClause__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassificationFromClause__Group__0__Impl
+ rule__ClassificationFromClause__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationFromClause__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationFromClauseAccess().getFromKeyword_0()); }
+
+ 'from'
+
+{ after(grammarAccess.getClassificationFromClauseAccess().getFromKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassificationFromClause__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassificationFromClause__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationFromClause__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationFromClauseAccess().getQualifiedNameListAssignment_1()); }
+(rule__ClassificationFromClause__QualifiedNameListAssignment_1)
+{ after(grammarAccess.getClassificationFromClauseAccess().getQualifiedNameListAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ClassificationToClause__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassificationToClause__Group__0__Impl
+ rule__ClassificationToClause__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationToClause__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationToClauseAccess().getToKeyword_0()); }
+
+ 'to'
+
+{ after(grammarAccess.getClassificationToClauseAccess().getToKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassificationToClause__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassificationToClause__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationToClause__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationToClauseAccess().getQualifiedNameListAssignment_1()); }
+(rule__ClassificationToClause__QualifiedNameListAssignment_1)
+{ after(grammarAccess.getClassificationToClauseAccess().getQualifiedNameListAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ReclassifyAllClause__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ReclassifyAllClause__Group__0__Impl
+ rule__ReclassifyAllClause__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ReclassifyAllClause__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getReclassifyAllClauseAccess().getReclassifyAllClauseAction_0()); }
+(
+
+)
+{ after(grammarAccess.getReclassifyAllClauseAccess().getReclassifyAllClauseAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ReclassifyAllClause__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ReclassifyAllClause__Group__1__Impl
+ rule__ReclassifyAllClause__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ReclassifyAllClause__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getReclassifyAllClauseAccess().getFromKeyword_1()); }
+
+ 'from'
+
+{ after(grammarAccess.getReclassifyAllClauseAccess().getFromKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ReclassifyAllClause__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ReclassifyAllClause__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ReclassifyAllClause__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getReclassifyAllClauseAccess().getAsteriskKeyword_2()); }
+
+ '*'
+
+{ after(grammarAccess.getReclassifyAllClauseAccess().getAsteriskKeyword_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__QualifiedNameList__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedNameList__Group__0__Impl
+ rule__QualifiedNameList__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameList__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getQualifiedNameListAccess().getQualifiedNameAssignment_0()); }
+(rule__QualifiedNameList__QualifiedNameAssignment_0)
+{ after(grammarAccess.getQualifiedNameListAccess().getQualifiedNameAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedNameList__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedNameList__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameList__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getQualifiedNameListAccess().getGroup_1()); }
+(rule__QualifiedNameList__Group_1__0)*
+{ after(grammarAccess.getQualifiedNameListAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__QualifiedNameList__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedNameList__Group_1__0__Impl
+ rule__QualifiedNameList__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameList__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getQualifiedNameListAccess().getCommaKeyword_1_0()); }
+
+ ','
+
+{ after(grammarAccess.getQualifiedNameListAccess().getCommaKeyword_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedNameList__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedNameList__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameList__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getQualifiedNameListAccess().getQualifiedNameAssignment_1_1()); }
+(rule__QualifiedNameList__QualifiedNameAssignment_1_1)
+{ after(grammarAccess.getQualifiedNameListAccess().getQualifiedNameAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__InvocationOrAssignementOrDeclarationStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InvocationOrAssignementOrDeclarationStatement__Group__0__Impl
+ rule__InvocationOrAssignementOrDeclarationStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InvocationOrAssignementOrDeclarationStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getTypePart_OR_assignedPart_OR_invocationPartAssignment_0()); }
+(rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0)
+{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getTypePart_OR_assignedPart_OR_invocationPartAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InvocationOrAssignementOrDeclarationStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InvocationOrAssignementOrDeclarationStatement__Group__1__Impl
+ rule__InvocationOrAssignementOrDeclarationStatement__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InvocationOrAssignementOrDeclarationStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAlternatives_1()); }
+(rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1)?
+{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAlternatives_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InvocationOrAssignementOrDeclarationStatement__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InvocationOrAssignementOrDeclarationStatement__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InvocationOrAssignementOrDeclarationStatement__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getSemicolonKeyword_2()); }
+
+ ';'
+
+{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getSemicolonKeyword_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__SuperInvocationStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SuperInvocationStatement__Group__0__Impl
+ rule__SuperInvocationStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSuperInvocationStatementAccess().get_superAssignment_0()); }
+(rule__SuperInvocationStatement___superAssignment_0)
+{ after(grammarAccess.getSuperInvocationStatementAccess().get_superAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__SuperInvocationStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__SuperInvocationStatement__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSuperInvocationStatementAccess().getSemicolonKeyword_1()); }
+
+ ';'
+
+{ after(grammarAccess.getSuperInvocationStatementAccess().getSemicolonKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ThisInvocationStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ThisInvocationStatement__Group__0__Impl
+ rule__ThisInvocationStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ThisInvocationStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getThisInvocationStatementAccess().get_thisAssignment_0()); }
+(rule__ThisInvocationStatement___thisAssignment_0)
+{ after(grammarAccess.getThisInvocationStatementAccess().get_thisAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ThisInvocationStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ThisInvocationStatement__Group__1__Impl
+ rule__ThisInvocationStatement__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ThisInvocationStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getThisInvocationStatementAccess().getAssignmentCompletionAssignment_1()); }
+(rule__ThisInvocationStatement__AssignmentCompletionAssignment_1)?
+{ after(grammarAccess.getThisInvocationStatementAccess().getAssignmentCompletionAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ThisInvocationStatement__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ThisInvocationStatement__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ThisInvocationStatement__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getThisInvocationStatementAccess().getSemicolonKeyword_2()); }
+
+ ';'
+
+{ after(grammarAccess.getThisInvocationStatementAccess().getSemicolonKeyword_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__InstanceCreationInvocationStatement__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InstanceCreationInvocationStatement__Group__0__Impl
+ rule__InstanceCreationInvocationStatement__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationInvocationStatement__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationInvocationStatementAccess().get_newAssignment_0()); }
+(rule__InstanceCreationInvocationStatement___newAssignment_0)
+{ after(grammarAccess.getInstanceCreationInvocationStatementAccess().get_newAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationInvocationStatement__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__InstanceCreationInvocationStatement__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationInvocationStatement__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationInvocationStatementAccess().getSemicolonKeyword_1()); }
+
+ ';'
+
+{ after(grammarAccess.getInstanceCreationInvocationStatementAccess().getSemicolonKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__VariableDeclarationCompletion__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__VariableDeclarationCompletion__Group__0__Impl
+ rule__VariableDeclarationCompletion__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__VariableDeclarationCompletion__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getVariableDeclarationCompletionAccess().getGroup_0()); }
+(rule__VariableDeclarationCompletion__Group_0__0)?
+{ after(grammarAccess.getVariableDeclarationCompletionAccess().getGroup_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__VariableDeclarationCompletion__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__VariableDeclarationCompletion__Group__1__Impl
+ rule__VariableDeclarationCompletion__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__VariableDeclarationCompletion__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getVariableDeclarationCompletionAccess().getVariableNameAssignment_1()); }
+(rule__VariableDeclarationCompletion__VariableNameAssignment_1)
+{ after(grammarAccess.getVariableDeclarationCompletionAccess().getVariableNameAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__VariableDeclarationCompletion__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__VariableDeclarationCompletion__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__VariableDeclarationCompletion__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getVariableDeclarationCompletionAccess().getInitValueAssignment_2()); }
+(rule__VariableDeclarationCompletion__InitValueAssignment_2)
+{ after(grammarAccess.getVariableDeclarationCompletionAccess().getInitValueAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__VariableDeclarationCompletion__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__VariableDeclarationCompletion__Group_0__0__Impl
+ rule__VariableDeclarationCompletion__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__VariableDeclarationCompletion__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getVariableDeclarationCompletionAccess().getMultiplicityIndicatorAssignment_0_0()); }
+(rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0)
+{ after(grammarAccess.getVariableDeclarationCompletionAccess().getMultiplicityIndicatorAssignment_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__VariableDeclarationCompletion__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__VariableDeclarationCompletion__Group_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__VariableDeclarationCompletion__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getVariableDeclarationCompletionAccess().getRightSquareBracketKeyword_0_1()); }
+
+ ']'
+
+{ after(grammarAccess.getVariableDeclarationCompletionAccess().getRightSquareBracketKeyword_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AssignmentCompletion__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignmentCompletion__Group__0__Impl
+ rule__AssignmentCompletion__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignmentCompletion__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignmentCompletionAccess().getOpAssignment_0()); }
+(rule__AssignmentCompletion__OpAssignment_0)
+{ after(grammarAccess.getAssignmentCompletionAccess().getOpAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AssignmentCompletion__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignmentCompletion__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignmentCompletion__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignmentCompletionAccess().getRightHandSideAssignment_1()); }
+(rule__AssignmentCompletion__RightHandSideAssignment_1)
+{ after(grammarAccess.getAssignmentCompletionAccess().getRightHandSideAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+rule__Test__ExpressionAssignment_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTestAccess().getExpressionExpressionParserRuleCall_0_1_0()); }
+ ruleExpression{ after(grammarAccess.getTestAccess().getExpressionExpressionParserRuleCall_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Test__AssignExpressionAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTestAccess().getAssignExpressionAssignmentCompletionParserRuleCall_1_1_0()); }
+ ruleAssignmentCompletion{ after(grammarAccess.getTestAccess().getAssignExpressionAssignmentCompletionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Test__StatementsAssignment_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTestAccess().getStatementsStatementParserRuleCall_2_1_0()); }
+ ruleStatement{ after(grammarAccess.getTestAccess().getStatementsStatementParserRuleCall_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Test__BlockAssignment_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTestAccess().getBlockBlockParserRuleCall_3_1_0()); }
+ ruleBlock{ after(grammarAccess.getTestAccess().getBlockBlockParserRuleCall_3_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__BOOLEAN_LITERAL__ValueAssignment
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBOOLEAN_LITERALAccess().getValueBooleanValueEnumRuleCall_0()); }
+ ruleBooleanValue{ after(grammarAccess.getBOOLEAN_LITERALAccess().getValueBooleanValueEnumRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__INTEGER_LITERAL__ValueAssignment
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getINTEGER_LITERALAccess().getValueIntegerValueTerminalRuleCall_0()); }
+ RULE_INTEGERVALUE{ after(grammarAccess.getINTEGER_LITERALAccess().getValueIntegerValueTerminalRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__UNLIMITED_LITERAL__ValueAssignment
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getUNLIMITED_LITERALAccess().getValueAsteriskKeyword_0()); }
+(
+{ before(grammarAccess.getUNLIMITED_LITERALAccess().getValueAsteriskKeyword_0()); }
+
+ '*'
+
+{ after(grammarAccess.getUNLIMITED_LITERALAccess().getValueAsteriskKeyword_0()); }
+)
+
+{ after(grammarAccess.getUNLIMITED_LITERALAccess().getValueAsteriskKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__STRING_LITERAL__ValueAssignment
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSTRING_LITERALAccess().getValueSTRINGTerminalRuleCall_0()); }
+ RULE_STRING{ after(grammarAccess.getSTRING_LITERALAccess().getValueSTRINGTerminalRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__PrefixOpAssignment_0_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPrefixOpAlternatives_0_0_0_0()); }
+(rule__NameExpression__PrefixOpAlternatives_0_0_0_0)
+{ after(grammarAccess.getNameExpressionAccess().getPrefixOpAlternatives_0_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__PathAssignment_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPathQualifiedNamePathParserRuleCall_0_0_1_0()); }
+ ruleQualifiedNamePath{ after(grammarAccess.getNameExpressionAccess().getPathQualifiedNamePathParserRuleCall_0_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__IdAssignment_0_0_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getIdIDTerminalRuleCall_0_0_2_0()); }
+ RULE_ID{ after(grammarAccess.getNameExpressionAccess().getIdIDTerminalRuleCall_0_0_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__PathAssignment_0_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPathQualifiedNamePathParserRuleCall_0_1_0_0()); }
+ ruleQualifiedNamePath{ after(grammarAccess.getNameExpressionAccess().getPathQualifiedNamePathParserRuleCall_0_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__IdAssignment_0_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getIdIDTerminalRuleCall_0_1_1_0()); }
+ RULE_ID{ after(grammarAccess.getNameExpressionAccess().getIdIDTerminalRuleCall_0_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__InvocationCompletionAssignment_0_1_2_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getInvocationCompletionTupleParserRuleCall_0_1_2_0_0()); }
+ ruleTuple{ after(grammarAccess.getNameExpressionAccess().getInvocationCompletionTupleParserRuleCall_0_1_2_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getSequenceConstructionCompletionSequenceConstructionOrAccessCompletionParserRuleCall_0_1_2_1_0()); }
+ ruleSequenceConstructionOrAccessCompletion{ after(grammarAccess.getNameExpressionAccess().getSequenceConstructionCompletionSequenceConstructionOrAccessCompletionParserRuleCall_0_1_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__PostfixOpAssignment_0_1_2_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPostfixOpAlternatives_0_1_2_2_0()); }
+(rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0)
+{ after(grammarAccess.getNameExpressionAccess().getPostfixOpAlternatives_0_1_2_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NameExpression__SuffixAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getSuffixSuffixExpressionParserRuleCall_1_0()); }
+ ruleSuffixExpression{ after(grammarAccess.getNameExpressionAccess().getSuffixSuffixExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNamePath__NamespaceAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getQualifiedNamePathAccess().getNamespaceUnqualifiedNameParserRuleCall_0_0()); }
+ ruleUnqualifiedName{ after(grammarAccess.getQualifiedNamePathAccess().getNamespaceUnqualifiedNameParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__UnqualifiedName__NameAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getUnqualifiedNameAccess().getNameIDTerminalRuleCall_0_0()); }
+ RULE_ID{ after(grammarAccess.getUnqualifiedNameAccess().getNameIDTerminalRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__UnqualifiedName__TemplateBindingAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getUnqualifiedNameAccess().getTemplateBindingTemplateBindingParserRuleCall_1_0()); }
+ ruleTemplateBinding{ after(grammarAccess.getUnqualifiedNameAccess().getTemplateBindingTemplateBindingParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TemplateBinding__BindingsAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTemplateBindingAccess().getBindingsNamedTemplateBindingParserRuleCall_1_0()); }
+ ruleNamedTemplateBinding{ after(grammarAccess.getTemplateBindingAccess().getBindingsNamedTemplateBindingParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TemplateBinding__BindingsAssignment_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTemplateBindingAccess().getBindingsNamedTemplateBindingParserRuleCall_2_1_0()); }
+ ruleNamedTemplateBinding{ after(grammarAccess.getTemplateBindingAccess().getBindingsNamedTemplateBindingParserRuleCall_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NamedTemplateBinding__FormalAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNamedTemplateBindingAccess().getFormalIDTerminalRuleCall_0_0()); }
+ RULE_ID{ after(grammarAccess.getNamedTemplateBindingAccess().getFormalIDTerminalRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NamedTemplateBinding__ActualAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNamedTemplateBindingAccess().getActualQualifiedNameWithBindingParserRuleCall_2_0()); }
+ ruleQualifiedNameWithBinding{ after(grammarAccess.getNamedTemplateBindingAccess().getActualQualifiedNameWithBindingParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithBinding__IdAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getIdIDTerminalRuleCall_0_0()); }
+ RULE_ID{ after(grammarAccess.getQualifiedNameWithBindingAccess().getIdIDTerminalRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithBinding__BindingAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getBindingTemplateBindingParserRuleCall_1_0()); }
+ ruleTemplateBinding{ after(grammarAccess.getQualifiedNameWithBindingAccess().getBindingTemplateBindingParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithBinding__RemainingAssignment_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getRemainingQualifiedNameWithBindingParserRuleCall_2_1_0()); }
+ ruleQualifiedNameWithBinding{ after(grammarAccess.getQualifiedNameWithBindingAccess().getRemainingQualifiedNameWithBindingParserRuleCall_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Tuple__TupleElementsAssignment_2_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTupleAccess().getTupleElementsTupleElementParserRuleCall_2_0_0()); }
+ ruleTupleElement{ after(grammarAccess.getTupleAccess().getTupleElementsTupleElementParserRuleCall_2_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Tuple__TupleElementsAssignment_2_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTupleAccess().getTupleElementsTupleElementParserRuleCall_2_1_1_0()); }
+ ruleTupleElement{ after(grammarAccess.getTupleAccess().getTupleElementsTupleElementParserRuleCall_2_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TupleElement__ArgumentAssignment
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTupleElementAccess().getArgumentExpressionParserRuleCall_0()); }
+ ruleExpression{ after(grammarAccess.getTupleElementAccess().getArgumentExpressionParserRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__ExpAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getExpConditionalOrExpressionParserRuleCall_0_0()); }
+ ruleConditionalOrExpression{ after(grammarAccess.getConditionalTestExpressionAccess().getExpConditionalOrExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__WhenTrueAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getWhenTrueConditionalTestExpressionParserRuleCall_1_1_0()); }
+ ruleConditionalTestExpression{ after(grammarAccess.getConditionalTestExpressionAccess().getWhenTrueConditionalTestExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__WhenFalseAssignment_1_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getWhenFalseConditionalTestExpressionParserRuleCall_1_3_0()); }
+ ruleConditionalTestExpression{ after(grammarAccess.getConditionalTestExpressionAccess().getWhenFalseConditionalTestExpressionParserRuleCall_1_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalOrExpression__ExpAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalOrExpressionAccess().getExpConditionalAndExpressionParserRuleCall_0_0()); }
+ ruleConditionalAndExpression{ after(grammarAccess.getConditionalOrExpressionAccess().getExpConditionalAndExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalOrExpression__ExpAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalOrExpressionAccess().getExpConditionalAndExpressionParserRuleCall_1_1_0()); }
+ ruleConditionalAndExpression{ after(grammarAccess.getConditionalOrExpressionAccess().getExpConditionalAndExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalAndExpression__ExpAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalAndExpressionAccess().getExpInclusiveOrExpressionParserRuleCall_0_0()); }
+ ruleInclusiveOrExpression{ after(grammarAccess.getConditionalAndExpressionAccess().getExpInclusiveOrExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConditionalAndExpression__ExpAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConditionalAndExpressionAccess().getExpInclusiveOrExpressionParserRuleCall_1_1_0()); }
+ ruleInclusiveOrExpression{ after(grammarAccess.getConditionalAndExpressionAccess().getExpInclusiveOrExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InclusiveOrExpression__ExpAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInclusiveOrExpressionAccess().getExpExclusiveOrExpressionParserRuleCall_0_0()); }
+ ruleExclusiveOrExpression{ after(grammarAccess.getInclusiveOrExpressionAccess().getExpExclusiveOrExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InclusiveOrExpression__ExpAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInclusiveOrExpressionAccess().getExpExclusiveOrExpressionParserRuleCall_1_1_0()); }
+ ruleExclusiveOrExpression{ after(grammarAccess.getInclusiveOrExpressionAccess().getExpExclusiveOrExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExclusiveOrExpression__ExpAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExclusiveOrExpressionAccess().getExpAndExpressionParserRuleCall_0_0()); }
+ ruleAndExpression{ after(grammarAccess.getExclusiveOrExpressionAccess().getExpAndExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExclusiveOrExpression__ExpAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExclusiveOrExpressionAccess().getExpAndExpressionParserRuleCall_1_1_0()); }
+ ruleAndExpression{ after(grammarAccess.getExclusiveOrExpressionAccess().getExpAndExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AndExpression__ExpAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAndExpressionAccess().getExpEqualityExpressionParserRuleCall_0_0()); }
+ ruleEqualityExpression{ after(grammarAccess.getAndExpressionAccess().getExpEqualityExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AndExpression__ExpAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAndExpressionAccess().getExpEqualityExpressionParserRuleCall_1_1_0()); }
+ ruleEqualityExpression{ after(grammarAccess.getAndExpressionAccess().getExpEqualityExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__EqualityExpression__ExpAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getExpClassificationExpressionParserRuleCall_0_0()); }
+ ruleClassificationExpression{ after(grammarAccess.getEqualityExpressionAccess().getExpClassificationExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__EqualityExpression__OpAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getOpAlternatives_1_0_0()); }
+(rule__EqualityExpression__OpAlternatives_1_0_0)
+{ after(grammarAccess.getEqualityExpressionAccess().getOpAlternatives_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__EqualityExpression__ExpAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getExpClassificationExpressionParserRuleCall_1_1_0()); }
+ ruleClassificationExpression{ after(grammarAccess.getEqualityExpressionAccess().getExpClassificationExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationExpression__ExpAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getExpRelationalExpressionParserRuleCall_0_0()); }
+ ruleRelationalExpression{ after(grammarAccess.getClassificationExpressionAccess().getExpRelationalExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationExpression__OpAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getOpAlternatives_1_0_0()); }
+(rule__ClassificationExpression__OpAlternatives_1_0_0)
+{ after(grammarAccess.getClassificationExpressionAccess().getOpAlternatives_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationExpression__TypeNameAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getTypeNameNameExpressionParserRuleCall_1_1_0()); }
+ ruleNameExpression{ after(grammarAccess.getClassificationExpressionAccess().getTypeNameNameExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RelationalExpression__LeftAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRelationalExpressionAccess().getLeftShiftExpressionParserRuleCall_0_0()); }
+ ruleShiftExpression{ after(grammarAccess.getRelationalExpressionAccess().getLeftShiftExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RelationalExpression__OpAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRelationalExpressionAccess().getOpAlternatives_1_0_0()); }
+(rule__RelationalExpression__OpAlternatives_1_0_0)
+{ after(grammarAccess.getRelationalExpressionAccess().getOpAlternatives_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RelationalExpression__RightAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRelationalExpressionAccess().getRightShiftExpressionParserRuleCall_1_1_0()); }
+ ruleShiftExpression{ after(grammarAccess.getRelationalExpressionAccess().getRightShiftExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ShiftExpression__ExpAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getShiftExpressionAccess().getExpAdditiveExpressionParserRuleCall_0_0()); }
+ ruleAdditiveExpression{ after(grammarAccess.getShiftExpressionAccess().getExpAdditiveExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ShiftExpression__OpAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getShiftExpressionAccess().getOpAlternatives_1_0_0()); }
+(rule__ShiftExpression__OpAlternatives_1_0_0)
+{ after(grammarAccess.getShiftExpressionAccess().getOpAlternatives_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ShiftExpression__ExpAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getShiftExpressionAccess().getExpAdditiveExpressionParserRuleCall_1_1_0()); }
+ ruleAdditiveExpression{ after(grammarAccess.getShiftExpressionAccess().getExpAdditiveExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AdditiveExpression__ExpAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAdditiveExpressionAccess().getExpMultiplicativeExpressionParserRuleCall_0_0()); }
+ ruleMultiplicativeExpression{ after(grammarAccess.getAdditiveExpressionAccess().getExpMultiplicativeExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AdditiveExpression__OpAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAdditiveExpressionAccess().getOpAlternatives_1_0_0()); }
+(rule__AdditiveExpression__OpAlternatives_1_0_0)
+{ after(grammarAccess.getAdditiveExpressionAccess().getOpAlternatives_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AdditiveExpression__ExpAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAdditiveExpressionAccess().getExpMultiplicativeExpressionParserRuleCall_1_1_0()); }
+ ruleMultiplicativeExpression{ after(grammarAccess.getAdditiveExpressionAccess().getExpMultiplicativeExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__MultiplicativeExpression__ExpAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getExpUnaryExpressionParserRuleCall_0_0()); }
+ ruleUnaryExpression{ after(grammarAccess.getMultiplicativeExpressionAccess().getExpUnaryExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__MultiplicativeExpression__OpAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getOpAlternatives_1_0_0()); }
+(rule__MultiplicativeExpression__OpAlternatives_1_0_0)
+{ after(grammarAccess.getMultiplicativeExpressionAccess().getOpAlternatives_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__MultiplicativeExpression__ExpAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getExpUnaryExpressionParserRuleCall_1_1_0()); }
+ ruleUnaryExpression{ after(grammarAccess.getMultiplicativeExpressionAccess().getExpUnaryExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__UnaryExpression__OpAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getUnaryExpressionAccess().getOpAlternatives_0_0()); }
+(rule__UnaryExpression__OpAlternatives_0_0)
+{ after(grammarAccess.getUnaryExpressionAccess().getOpAlternatives_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__UnaryExpression__ExpAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getUnaryExpressionAccess().getExpPrimaryExpressionParserRuleCall_1_0()); }
+ rulePrimaryExpression{ after(grammarAccess.getUnaryExpressionAccess().getExpPrimaryExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__PrefixAssignment
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getPrefixValueSpecificationParserRuleCall_0()); }
+ ruleValueSpecification{ after(grammarAccess.getPrimaryExpressionAccess().getPrefixValueSpecificationParserRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OperationCallExpression__OperationNameAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getOperationCallExpressionAccess().getOperationNameIDTerminalRuleCall_1_0()); }
+ RULE_ID{ after(grammarAccess.getOperationCallExpressionAccess().getOperationNameIDTerminalRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OperationCallExpression__TupleAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getOperationCallExpressionAccess().getTupleTupleParserRuleCall_2_0()); }
+ ruleTuple{ after(grammarAccess.getOperationCallExpressionAccess().getTupleTupleParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OperationCallExpression__SuffixAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getOperationCallExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); }
+ ruleSuffixExpression{ after(grammarAccess.getOperationCallExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__PropertyNameAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getPropertyNameIDTerminalRuleCall_1_0()); }
+ RULE_ID{ after(grammarAccess.getPropertyCallExpressionAccess().getPropertyNameIDTerminalRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__IndexAssignment_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getIndexExpressionParserRuleCall_2_1_0()); }
+ ruleExpression{ after(grammarAccess.getPropertyCallExpressionAccess().getIndexExpressionParserRuleCall_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__SuffixAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); }
+ ruleSuffixExpression{ after(grammarAccess.getPropertyCallExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationExpression__KindAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationExpressionAccess().getKindLinkOperationKindEnumRuleCall_1_0()); }
+ ruleLinkOperationKind{ after(grammarAccess.getLinkOperationExpressionAccess().getKindLinkOperationKindEnumRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationExpression__TupleAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationExpressionAccess().getTupleLinkOperationTupleParserRuleCall_2_0()); }
+ ruleLinkOperationTuple{ after(grammarAccess.getLinkOperationExpressionAccess().getTupleLinkOperationTupleParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementLinkOperationTupleElementParserRuleCall_1_0()); }
+ ruleLinkOperationTupleElement{ after(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementLinkOperationTupleElementParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementLinkOperationTupleElementParserRuleCall_2_1_0()); }
+ ruleLinkOperationTupleElement{ after(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementLinkOperationTupleElementParserRuleCall_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__RoleAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getRoleIDTerminalRuleCall_0_0()); }
+ RULE_ID{ after(grammarAccess.getLinkOperationTupleElementAccess().getRoleIDTerminalRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__RoleIndexAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getRoleIndexExpressionParserRuleCall_1_1_0()); }
+ ruleExpression{ after(grammarAccess.getLinkOperationTupleElementAccess().getRoleIndexExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__ObjectAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getObjectExpressionParserRuleCall_3_0()); }
+ ruleExpression{ after(grammarAccess.getLinkOperationTupleElementAccess().getObjectExpressionParserRuleCall_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceOperationExpression__OperationNameAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceOperationExpressionAccess().getOperationNameQualifiedNameWithBindingParserRuleCall_1_0()); }
+ ruleQualifiedNameWithBinding{ after(grammarAccess.getSequenceOperationExpressionAccess().getOperationNameQualifiedNameWithBindingParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceOperationExpression__TupleAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceOperationExpressionAccess().getTupleTupleParserRuleCall_2_0()); }
+ ruleTuple{ after(grammarAccess.getSequenceOperationExpressionAccess().getTupleTupleParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceOperationExpression__SuffixAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceOperationExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); }
+ ruleSuffixExpression{ after(grammarAccess.getSequenceOperationExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceReductionExpression__IsOrderedAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedOrderedKeyword_2_0()); }
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedOrderedKeyword_2_0()); }
+
+ 'ordered'
+
+{ after(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedOrderedKeyword_2_0()); }
+)
+
+{ after(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedOrderedKeyword_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceReductionExpression__BehaviorAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getBehaviorQualifiedNameWithBindingParserRuleCall_3_0()); }
+ ruleQualifiedNameWithBinding{ after(grammarAccess.getSequenceReductionExpressionAccess().getBehaviorQualifiedNameWithBindingParserRuleCall_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceReductionExpression__SuffixAssignment_4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getSuffixSuffixExpressionParserRuleCall_4_0()); }
+ ruleSuffixExpression{ after(grammarAccess.getSequenceReductionExpressionAccess().getSuffixSuffixExpressionParserRuleCall_4_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__OpAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getOpSelectOrRejectOperatorEnumRuleCall_1_0()); }
+ ruleSelectOrRejectOperator{ after(grammarAccess.getSelectOrRejectOperationAccess().getOpSelectOrRejectOperatorEnumRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__NameAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getNameIDTerminalRuleCall_2_0()); }
+ RULE_ID{ after(grammarAccess.getSelectOrRejectOperationAccess().getNameIDTerminalRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__ExprAssignment_4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getExprExpressionParserRuleCall_4_0()); }
+ ruleExpression{ after(grammarAccess.getSelectOrRejectOperationAccess().getExprExpressionParserRuleCall_4_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__SuffixAssignment_6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); }
+ ruleSuffixExpression{ after(grammarAccess.getSelectOrRejectOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__OpAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getOpCollectOrIterateOperatorEnumRuleCall_1_0()); }
+ ruleCollectOrIterateOperator{ after(grammarAccess.getCollectOrIterateOperationAccess().getOpCollectOrIterateOperatorEnumRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__NameAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getNameIDTerminalRuleCall_2_0()); }
+ RULE_ID{ after(grammarAccess.getCollectOrIterateOperationAccess().getNameIDTerminalRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__ExprAssignment_4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getExprExpressionParserRuleCall_4_0()); }
+ ruleExpression{ after(grammarAccess.getCollectOrIterateOperationAccess().getExprExpressionParserRuleCall_4_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__SuffixAssignment_6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); }
+ ruleSuffixExpression{ after(grammarAccess.getCollectOrIterateOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__OpAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getOpForAllOrExistsOrOneOperatorEnumRuleCall_1_0()); }
+ ruleForAllOrExistsOrOneOperator{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getOpForAllOrExistsOrOneOperatorEnumRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__NameAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getNameIDTerminalRuleCall_2_0()); }
+ RULE_ID{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getNameIDTerminalRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__ExprAssignment_4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getExprExpressionParserRuleCall_4_0()); }
+ ruleExpression{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getExprExpressionParserRuleCall_4_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); }
+ ruleSuffixExpression{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__NameAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getNameIDTerminalRuleCall_2_0()); }
+ RULE_ID{ after(grammarAccess.getIsUniqueOperationAccess().getNameIDTerminalRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__ExprAssignment_4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getExprExpressionParserRuleCall_4_0()); }
+ ruleExpression{ after(grammarAccess.getIsUniqueOperationAccess().getExprExpressionParserRuleCall_4_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__SuffixAssignment_6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); }
+ ruleSuffixExpression{ after(grammarAccess.getIsUniqueOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getExpOrTypeCastExpressionParserRuleCall_1_0()); }
+ ruleExpression{ after(grammarAccess.getParenthesizedExpressionAccess().getExpOrTypeCastExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ParenthesizedExpression__CastedAssignment_3_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getCastedNonLiteralValueSpecificationParserRuleCall_3_0_0()); }
+ ruleNonLiteralValueSpecification{ after(grammarAccess.getParenthesizedExpressionAccess().getCastedNonLiteralValueSpecificationParserRuleCall_3_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ParenthesizedExpression__SuffixAssignment_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_1_0()); }
+ ruleSuffixExpression{ after(grammarAccess.getParenthesizedExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ThisExpression__SuffixAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getThisExpressionAccess().getSuffixSuffixExpressionParserRuleCall_2_0()); }
+ ruleSuffixExpression{ after(grammarAccess.getThisExpressionAccess().getSuffixSuffixExpressionParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__TupleAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getTupleTupleParserRuleCall_1_0_0()); }
+ ruleTuple{ after(grammarAccess.getSuperInvocationExpressionAccess().getTupleTupleParserRuleCall_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__OperationNameAssignment_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getOperationNameQualifiedNameWithBindingParserRuleCall_1_1_1_0()); }
+ ruleQualifiedNameWithBinding{ after(grammarAccess.getSuperInvocationExpressionAccess().getOperationNameQualifiedNameWithBindingParserRuleCall_1_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__TupleAssignment_1_1_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getTupleTupleParserRuleCall_1_1_2_0()); }
+ ruleTuple{ after(grammarAccess.getSuperInvocationExpressionAccess().getTupleTupleParserRuleCall_1_1_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationExpression__ConstructorAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationExpressionAccess().getConstructorQualifiedNameWithBindingParserRuleCall_1_0()); }
+ ruleQualifiedNameWithBinding{ after(grammarAccess.getInstanceCreationExpressionAccess().getConstructorQualifiedNameWithBindingParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationExpression__TupleAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationExpressionAccess().getTupleInstanceCreationTupleParserRuleCall_2_0()); }
+ ruleInstanceCreationTuple{ after(grammarAccess.getInstanceCreationExpressionAccess().getTupleInstanceCreationTupleParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationExpression__SuffixAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); }
+ ruleSuffixExpression{ after(grammarAccess.getInstanceCreationExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementInstanceCreationTupleElementParserRuleCall_2_0_0()); }
+ ruleInstanceCreationTupleElement{ after(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementInstanceCreationTupleElementParserRuleCall_2_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementInstanceCreationTupleElementParserRuleCall_2_1_1_0()); }
+ ruleInstanceCreationTupleElement{ after(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementInstanceCreationTupleElementParserRuleCall_2_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTupleElement__RoleAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleElementAccess().getRoleIDTerminalRuleCall_0_0()); }
+ RULE_ID{ after(grammarAccess.getInstanceCreationTupleElementAccess().getRoleIDTerminalRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTupleElement__ObjectAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleElementAccess().getObjectExpressionParserRuleCall_2_0()); }
+ ruleExpression{ after(grammarAccess.getInstanceCreationTupleElementAccess().getObjectExpressionParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); }
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); }
+
+ '['
+
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); }
+)
+
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAccessCompletionAccessCompletionParserRuleCall_0_1_0_0()); }
+ ruleAccessCompletion{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAccessCompletionAccessCompletionParserRuleCall_0_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getSequenceCompletionPartialSequenceConstructionCompletionParserRuleCall_0_1_1_0()); }
+ rulePartialSequenceConstructionCompletion{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getSequenceCompletionPartialSequenceConstructionCompletionParserRuleCall_0_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getExpressionSequenceConstructionExpressionParserRuleCall_1_0()); }
+ ruleSequenceConstructionExpression{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getExpressionSequenceConstructionExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AccessCompletion__AccessIndexAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAccessCompletionAccess().getAccessIndexExpressionParserRuleCall_0_0()); }
+ ruleExpression{ after(grammarAccess.getAccessCompletionAccess().getAccessIndexExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPartialSequenceConstructionCompletionAccess().getExpressionSequenceConstructionExpressionParserRuleCall_1_0()); }
+ ruleSequenceConstructionExpression{ after(grammarAccess.getPartialSequenceConstructionCompletionAccess().getExpressionSequenceConstructionExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__SequenceElementAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementSequenceElementParserRuleCall_1_0()); }
+ ruleSequenceElement{ after(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementSequenceElementParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementSequenceElementParserRuleCall_2_0_1_0()); }
+ ruleSequenceElement{ after(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementSequenceElementParserRuleCall_2_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getRangeUpperExpressionParserRuleCall_2_1_1_0()); }
+ ruleExpression{ after(grammarAccess.getSequenceConstructionExpressionAccess().getRangeUpperExpressionParserRuleCall_2_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Block__SequenceAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBlockAccess().getSequenceStatementSequenceParserRuleCall_2_0()); }
+ ruleStatementSequence{ after(grammarAccess.getBlockAccess().getSequenceStatementSequenceParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__StatementSequence__StatementsAssignment
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getStatementSequenceAccess().getStatementsDocumentedStatementParserRuleCall_0()); }
+ ruleDocumentedStatement{ after(grammarAccess.getStatementSequenceAccess().getStatementsDocumentedStatementParserRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DocumentedStatement__CommentAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDocumentedStatementAccess().getCommentAlternatives_0_0()); }
+(rule__DocumentedStatement__CommentAlternatives_0_0)
+{ after(grammarAccess.getDocumentedStatementAccess().getCommentAlternatives_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DocumentedStatement__StatementAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDocumentedStatementAccess().getStatementStatementParserRuleCall_1_0()); }
+ ruleStatement{ after(grammarAccess.getDocumentedStatementAccess().getStatementStatementParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__LangageNameAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getLangageNameIDTerminalRuleCall_3_0()); }
+ RULE_ID{ after(grammarAccess.getInlineStatementAccess().getLangageNameIDTerminalRuleCall_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__BodyAssignment_5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getBodySTRINGTerminalRuleCall_5_0()); }
+ RULE_STRING{ after(grammarAccess.getInlineStatementAccess().getBodySTRINGTerminalRuleCall_5_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AnnotatedStatement__AnnotationAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotatedStatementAccess().getAnnotationAnnotationParserRuleCall_1_0()); }
+ ruleAnnotation{ after(grammarAccess.getAnnotatedStatementAccess().getAnnotationAnnotationParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AnnotatedStatement__StatementAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotatedStatementAccess().getStatementStatementParserRuleCall_2_0()); }
+ ruleStatement{ after(grammarAccess.getAnnotatedStatementAccess().getStatementStatementParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Annotation__KindAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getKindAnnotationKindEnumRuleCall_0_0()); }
+ ruleAnnotationKind{ after(grammarAccess.getAnnotationAccess().getKindAnnotationKindEnumRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Annotation__ArgsAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getArgsIDTerminalRuleCall_1_1_0()); }
+ RULE_ID{ after(grammarAccess.getAnnotationAccess().getArgsIDTerminalRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Annotation__ArgsAssignment_1_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getArgsIDTerminalRuleCall_1_2_1_0()); }
+ RULE_ID{ after(grammarAccess.getAnnotationAccess().getArgsIDTerminalRuleCall_1_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__BlockStatement__BlockAssignment
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBlockStatementAccess().getBlockBlockParserRuleCall_0()); }
+ ruleBlock{ after(grammarAccess.getBlockStatementAccess().getBlockBlockParserRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__VarNameAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getVarNameIDTerminalRuleCall_1_0()); }
+ RULE_ID{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getVarNameIDTerminalRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__TypeAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getTypeQualifiedNameWithBindingParserRuleCall_3_0()); }
+ ruleQualifiedNameWithBinding{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getTypeQualifiedNameWithBindingParserRuleCall_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_4_0_0()); }
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_4_0_0()); }
+
+ '['
+
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_4_0_0()); }
+)
+
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_4_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__InitAssignment_6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getInitSequenceElementParserRuleCall_6_0()); }
+ ruleSequenceElement{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getInitSequenceElementParserRuleCall_6_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IfStatement__SequentialClaussesAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIfStatementAccess().getSequentialClaussesSequentialClausesParserRuleCall_1_0()); }
+ ruleSequentialClauses{ after(grammarAccess.getIfStatementAccess().getSequentialClaussesSequentialClausesParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IfStatement__FinalClauseAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIfStatementAccess().getFinalClauseFinalClauseParserRuleCall_2_0()); }
+ ruleFinalClause{ after(grammarAccess.getIfStatementAccess().getFinalClauseFinalClauseParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequentialClauses__ConccurentClausesAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequentialClausesAccess().getConccurentClausesConcurrentClausesParserRuleCall_0_0()); }
+ ruleConcurrentClauses{ after(grammarAccess.getSequentialClausesAccess().getConccurentClausesConcurrentClausesParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SequentialClauses__ConccurentClausesAssignment_1_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSequentialClausesAccess().getConccurentClausesConcurrentClausesParserRuleCall_1_2_0()); }
+ ruleConcurrentClauses{ after(grammarAccess.getSequentialClausesAccess().getConccurentClausesConcurrentClausesParserRuleCall_1_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConcurrentClauses__NonFinalClauseAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseNonFinalClauseParserRuleCall_0_0()); }
+ ruleNonFinalClause{ after(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseNonFinalClauseParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ConcurrentClauses__NonFinalClauseAssignment_1_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseNonFinalClauseParserRuleCall_1_2_0()); }
+ ruleNonFinalClause{ after(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseNonFinalClauseParserRuleCall_1_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NonFinalClause__ConditionAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNonFinalClauseAccess().getConditionExpressionParserRuleCall_1_0()); }
+ ruleExpression{ after(grammarAccess.getNonFinalClauseAccess().getConditionExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NonFinalClause__BlockAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNonFinalClauseAccess().getBlockBlockParserRuleCall_3_0()); }
+ ruleBlock{ after(grammarAccess.getNonFinalClauseAccess().getBlockBlockParserRuleCall_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__FinalClause__BlockAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getFinalClauseAccess().getBlockBlockParserRuleCall_1_0()); }
+ ruleBlock{ after(grammarAccess.getFinalClauseAccess().getBlockBlockParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__ExpressionAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getExpressionExpressionParserRuleCall_2_0()); }
+ ruleExpression{ after(grammarAccess.getSwitchStatementAccess().getExpressionExpressionParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__SwitchClauseAssignment_5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getSwitchClauseSwitchClauseParserRuleCall_5_0()); }
+ ruleSwitchClause{ after(grammarAccess.getSwitchStatementAccess().getSwitchClauseSwitchClauseParserRuleCall_5_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__DefaultClauseAssignment_6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getDefaultClauseSwitchDefaultClauseParserRuleCall_6_0()); }
+ ruleSwitchDefaultClause{ after(grammarAccess.getSwitchStatementAccess().getDefaultClauseSwitchDefaultClauseParserRuleCall_6_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchClause__SwitchCaseAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchClauseAccess().getSwitchCaseSwitchCaseParserRuleCall_0_0()); }
+ ruleSwitchCase{ after(grammarAccess.getSwitchClauseAccess().getSwitchCaseSwitchCaseParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchClause__SwitchCaseAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchClauseAccess().getSwitchCaseSwitchCaseParserRuleCall_1_0()); }
+ ruleSwitchCase{ after(grammarAccess.getSwitchClauseAccess().getSwitchCaseSwitchCaseParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchClause__StatementSequenceAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchClauseAccess().getStatementSequenceNonEmptyStatementSequenceParserRuleCall_2_0()); }
+ ruleNonEmptyStatementSequence{ after(grammarAccess.getSwitchClauseAccess().getStatementSequenceNonEmptyStatementSequenceParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchCase__ExpressionAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchCaseAccess().getExpressionExpressionParserRuleCall_1_0()); }
+ ruleExpression{ after(grammarAccess.getSwitchCaseAccess().getExpressionExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SwitchDefaultClause__StatementSequenceAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSwitchDefaultClauseAccess().getStatementSequenceNonEmptyStatementSequenceParserRuleCall_2_0()); }
+ ruleNonEmptyStatementSequence{ after(grammarAccess.getSwitchDefaultClauseAccess().getStatementSequenceNonEmptyStatementSequenceParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NonEmptyStatementSequence__StatementAssignment
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementDocumentedStatementParserRuleCall_0()); }
+ ruleDocumentedStatement{ after(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementDocumentedStatementParserRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__WhileStatement__ConditionAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getWhileStatementAccess().getConditionExpressionParserRuleCall_2_0()); }
+ ruleExpression{ after(grammarAccess.getWhileStatementAccess().getConditionExpressionParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__WhileStatement__BlockAssignment_4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getWhileStatementAccess().getBlockBlockParserRuleCall_4_0()); }
+ ruleBlock{ after(grammarAccess.getWhileStatementAccess().getBlockBlockParserRuleCall_4_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DoStatement__BlockAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getBlockBlockParserRuleCall_1_0()); }
+ ruleBlock{ after(grammarAccess.getDoStatementAccess().getBlockBlockParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DoStatement__ConditionAssignment_4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getConditionExpressionParserRuleCall_4_0()); }
+ ruleExpression{ after(grammarAccess.getDoStatementAccess().getConditionExpressionParserRuleCall_4_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForStatement__ControlAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForStatementAccess().getControlForControlParserRuleCall_2_0()); }
+ ruleForControl{ after(grammarAccess.getForStatementAccess().getControlForControlParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForStatement__BlockAssignment_4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForStatementAccess().getBlockBlockParserRuleCall_4_0()); }
+ ruleBlock{ after(grammarAccess.getForStatementAccess().getBlockBlockParserRuleCall_4_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForControl__LoopVariableDefinitionAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForControlAccess().getLoopVariableDefinitionLoopVariableDefinitionParserRuleCall_0_0()); }
+ ruleLoopVariableDefinition{ after(grammarAccess.getForControlAccess().getLoopVariableDefinitionLoopVariableDefinitionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForControl__LoopVariableDefinitionAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForControlAccess().getLoopVariableDefinitionLoopVariableDefinitionParserRuleCall_1_1_0()); }
+ ruleLoopVariableDefinition{ after(grammarAccess.getForControlAccess().getLoopVariableDefinitionLoopVariableDefinitionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__NameAssignment_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getNameIDTerminalRuleCall_0_0_0()); }
+ RULE_ID{ after(grammarAccess.getLoopVariableDefinitionAccess().getNameIDTerminalRuleCall_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Expression1Assignment_0_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getExpression1ExpressionParserRuleCall_0_2_0()); }
+ ruleExpression{ after(grammarAccess.getLoopVariableDefinitionAccess().getExpression1ExpressionParserRuleCall_0_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Expression2Assignment_0_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getExpression2ExpressionParserRuleCall_0_3_1_0()); }
+ ruleExpression{ after(grammarAccess.getLoopVariableDefinitionAccess().getExpression2ExpressionParserRuleCall_0_3_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__TypeAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getTypeQualifiedNameWithBindingParserRuleCall_1_0_0()); }
+ ruleQualifiedNameWithBinding{ after(grammarAccess.getLoopVariableDefinitionAccess().getTypeQualifiedNameWithBindingParserRuleCall_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__NameAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getNameIDTerminalRuleCall_1_1_0()); }
+ RULE_ID{ after(grammarAccess.getLoopVariableDefinitionAccess().getNameIDTerminalRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__ExpressionAssignment_1_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getExpressionExpressionParserRuleCall_1_3_0()); }
+ ruleExpression{ after(grammarAccess.getLoopVariableDefinitionAccess().getExpressionExpressionParserRuleCall_1_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ReturnStatement__ExpressionAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getReturnStatementAccess().getExpressionExpressionParserRuleCall_1_0()); }
+ ruleExpression{ after(grammarAccess.getReturnStatementAccess().getExpressionExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptStatement__ClauseAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptStatementAccess().getClauseAcceptClauseParserRuleCall_0_0()); }
+ ruleAcceptClause{ after(grammarAccess.getAcceptStatementAccess().getClauseAcceptClauseParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptStatement__SimpleAcceptAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptStatementAccess().getSimpleAcceptSimpleAcceptStatementCompletionParserRuleCall_1_0_0()); }
+ ruleSimpleAcceptStatementCompletion{ after(grammarAccess.getAcceptStatementAccess().getSimpleAcceptSimpleAcceptStatementCompletionParserRuleCall_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptStatement__CompoundAcceptAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptStatementAccess().getCompoundAcceptCompoundAcceptStatementCompletionParserRuleCall_1_1_0()); }
+ ruleCompoundAcceptStatementCompletion{ after(grammarAccess.getAcceptStatementAccess().getCompoundAcceptCompoundAcceptStatementCompletionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CompoundAcceptStatementCompletion__BlockAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getBlockBlockParserRuleCall_0_0()); }
+ ruleBlock{ after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getBlockBlockParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getAcceptBlockAcceptBlockParserRuleCall_1_1_0()); }
+ ruleAcceptBlock{ after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getAcceptBlockAcceptBlockParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptBlock__ClauseAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptBlockAccess().getClauseAcceptClauseParserRuleCall_0_0()); }
+ ruleAcceptClause{ after(grammarAccess.getAcceptBlockAccess().getClauseAcceptClauseParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptBlock__BlockAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptBlockAccess().getBlockBlockParserRuleCall_1_0()); }
+ ruleBlock{ after(grammarAccess.getAcceptBlockAccess().getBlockBlockParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__NameAssignment_2_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getNameIDTerminalRuleCall_2_0_0()); }
+ RULE_ID{ after(grammarAccess.getAcceptClauseAccess().getNameIDTerminalRuleCall_2_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__QualifiedNameListAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_3_0()); }
+ ruleQualifiedNameList{ after(grammarAccess.getAcceptClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassifyStatement__ExpressionAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassifyStatementAccess().getExpressionExpressionParserRuleCall_1_0()); }
+ ruleExpression{ after(grammarAccess.getClassifyStatementAccess().getExpressionExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassifyStatement__ClauseAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassifyStatementAccess().getClauseClassificationClauseParserRuleCall_2_0()); }
+ ruleClassificationClause{ after(grammarAccess.getClassifyStatementAccess().getClauseClassificationClauseParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__ClassifyFromClauseAssignment_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getClassifyFromClauseClassificationFromClauseParserRuleCall_0_0_0()); }
+ ruleClassificationFromClause{ after(grammarAccess.getClassificationClauseAccess().getClassifyFromClauseClassificationFromClauseParserRuleCall_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__ClassifyToClauseAssignment_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getClassifyToClauseClassificationToClauseParserRuleCall_0_1_0()); }
+ ruleClassificationToClause{ after(grammarAccess.getClassificationClauseAccess().getClassifyToClauseClassificationToClauseParserRuleCall_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__ReclassyAllClauseAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getReclassyAllClauseReclassifyAllClauseParserRuleCall_1_0_0()); }
+ ruleReclassifyAllClause{ after(grammarAccess.getClassificationClauseAccess().getReclassyAllClauseReclassifyAllClauseParserRuleCall_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__ClassifyToClauseAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getClassifyToClauseClassificationToClauseParserRuleCall_1_1_0()); }
+ ruleClassificationToClause{ after(grammarAccess.getClassificationClauseAccess().getClassifyToClauseClassificationToClauseParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationFromClause__QualifiedNameListAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationFromClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_1_0()); }
+ ruleQualifiedNameList{ after(grammarAccess.getClassificationFromClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassificationToClause__QualifiedNameListAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassificationToClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_1_0()); }
+ ruleQualifiedNameList{ after(grammarAccess.getClassificationToClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameList__QualifiedNameAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getQualifiedNameListAccess().getQualifiedNameQualifiedNameWithBindingParserRuleCall_0_0()); }
+ ruleQualifiedNameWithBinding{ after(grammarAccess.getQualifiedNameListAccess().getQualifiedNameQualifiedNameWithBindingParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameList__QualifiedNameAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getQualifiedNameListAccess().getQualifiedNameQualifiedNameWithBindingParserRuleCall_1_1_0()); }
+ ruleQualifiedNameWithBinding{ after(grammarAccess.getQualifiedNameListAccess().getQualifiedNameQualifiedNameWithBindingParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getTypePart_OR_assignedPart_OR_invocationPartNameExpressionParserRuleCall_0_0()); }
+ ruleNameExpression{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getTypePart_OR_assignedPart_OR_invocationPartNameExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getVariableDeclarationCompletionVariableDeclarationCompletionParserRuleCall_1_0_0()); }
+ ruleVariableDeclarationCompletion{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getVariableDeclarationCompletionVariableDeclarationCompletionParserRuleCall_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAssignmentCompletionAssignmentCompletionParserRuleCall_1_1_0()); }
+ ruleAssignmentCompletion{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAssignmentCompletionAssignmentCompletionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationStatement___superAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSuperInvocationStatementAccess().get_superSuperInvocationExpressionParserRuleCall_0_0()); }
+ ruleSuperInvocationExpression{ after(grammarAccess.getSuperInvocationStatementAccess().get_superSuperInvocationExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ThisInvocationStatement___thisAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getThisInvocationStatementAccess().get_thisThisExpressionParserRuleCall_0_0()); }
+ ruleThisExpression{ after(grammarAccess.getThisInvocationStatementAccess().get_thisThisExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ThisInvocation