parallel ip - initial checkin
Signed-off-by: Ralf Mollik <ramollik@compex-commerce.com>
diff --git a/.project b/.project
new file mode 100644
index 0000000..9d6926d
--- /dev/null
+++ b/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>org.eclipse.osbp.xtext.oxtype.parent</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.m2e.core.maven2Builder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.m2e.core.maven2Nature</nature>
+ </natures>
+</projectDescription>
diff --git a/epl-v10.html b/epl-v10.html
new file mode 100644
index 0000000..b398acc
--- /dev/null
+++ b/epl-v10.html
@@ -0,0 +1,259 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Public License - Version 1.0</title>
+<style type="text/css">
+ body {
+ size: 8.5in 11.0in;
+ margin: 0.25in 0.5in 0.25in 0.5in;
+ tab-interval: 0.5in;
+ }
+ p {
+ margin-left: auto;
+ margin-top: 0.5em;
+ margin-bottom: 0.5em;
+ }
+ p.list {
+ margin-left: 0.5in;
+ margin-top: 0.05em;
+ margin-bottom: 0.05em;
+ }
+ </style>
+
+</head>
+
+<body lang="EN-US">
+
+<h2>Eclipse Public License - v 1.0</h2>
+
+<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
+DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
+AGREEMENT.</p>
+
+<p><b>1. DEFINITIONS</b></p>
+
+<p>"Contribution" means:</p>
+
+<p class="list">a) in the case of the initial Contributor, the initial
+code and documentation distributed under this Agreement, and</p>
+<p class="list">b) in the case of each subsequent Contributor:</p>
+<p class="list">i) changes to the Program, and</p>
+<p class="list">ii) additions to the Program;</p>
+<p class="list">where such changes and/or additions to the Program
+originate from and are distributed by that particular Contributor. A
+Contribution 'originates' from a Contributor if it was added to the
+Program by such Contributor itself or anyone acting on such
+Contributor's behalf. Contributions do not include additions to the
+Program which: (i) are separate modules of software distributed in
+conjunction with the Program under their own license agreement, and (ii)
+are not derivative works of the Program.</p>
+
+<p>"Contributor" means any person or entity that distributes
+the Program.</p>
+
+<p>"Licensed Patents" mean patent claims licensable by a
+Contributor which are necessarily infringed by the use or sale of its
+Contribution alone or when combined with the Program.</p>
+
+<p>"Program" means the Contributions distributed in accordance
+with this Agreement.</p>
+
+<p>"Recipient" means anyone who receives the Program under
+this Agreement, including all Contributors.</p>
+
+<p><b>2. GRANT OF RIGHTS</b></p>
+
+<p class="list">a) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works
+of, publicly display, publicly perform, distribute and sublicense the
+Contribution of such Contributor, if any, and such derivative works, in
+source code and object code form.</p>
+
+<p class="list">b) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell,
+offer to sell, import and otherwise transfer the Contribution of such
+Contributor, if any, in source code and object code form. This patent
+license shall apply to the combination of the Contribution and the
+Program if, at the time the Contribution is added by the Contributor,
+such addition of the Contribution causes such combination to be covered
+by the Licensed Patents. The patent license shall not apply to any other
+combinations which include the Contribution. No hardware per se is
+licensed hereunder.</p>
+
+<p class="list">c) Recipient understands that although each Contributor
+grants the licenses to its Contributions set forth herein, no assurances
+are provided by any Contributor that the Program does not infringe the
+patent or other intellectual property rights of any other entity. Each
+Contributor disclaims any liability to Recipient for claims brought by
+any other entity based on infringement of intellectual property rights
+or otherwise. As a condition to exercising the rights and licenses
+granted hereunder, each Recipient hereby assumes sole responsibility to
+secure any other intellectual property rights needed, if any. For
+example, if a third party patent license is required to allow Recipient
+to distribute the Program, it is Recipient's responsibility to acquire
+that license before distributing the Program.</p>
+
+<p class="list">d) Each Contributor represents that to its knowledge it
+has sufficient copyright rights in its Contribution, if any, to grant
+the copyright license set forth in this Agreement.</p>
+
+<p><b>3. REQUIREMENTS</b></p>
+
+<p>A Contributor may choose to distribute the Program in object code
+form under its own license agreement, provided that:</p>
+
+<p class="list">a) it complies with the terms and conditions of this
+Agreement; and</p>
+
+<p class="list">b) its license agreement:</p>
+
+<p class="list">i) effectively disclaims on behalf of all Contributors
+all warranties and conditions, express and implied, including warranties
+or conditions of title and non-infringement, and implied warranties or
+conditions of merchantability and fitness for a particular purpose;</p>
+
+<p class="list">ii) effectively excludes on behalf of all Contributors
+all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;</p>
+
+<p class="list">iii) states that any provisions which differ from this
+Agreement are offered by that Contributor alone and not by any other
+party; and</p>
+
+<p class="list">iv) states that source code for the Program is available
+from such Contributor, and informs licensees how to obtain it in a
+reasonable manner on or through a medium customarily used for software
+exchange.</p>
+
+<p>When the Program is made available in source code form:</p>
+
+<p class="list">a) it must be made available under this Agreement; and</p>
+
+<p class="list">b) a copy of this Agreement must be included with each
+copy of the Program.</p>
+
+<p>Contributors may not remove or alter any copyright notices contained
+within the Program.</p>
+
+<p>Each Contributor must identify itself as the originator of its
+Contribution, if any, in a manner that reasonably allows subsequent
+Recipients to identify the originator of the Contribution.</p>
+
+<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
+
+<p>Commercial distributors of software may accept certain
+responsibilities with respect to end users, business partners and the
+like. While this license is intended to facilitate the commercial use of
+the Program, the Contributor who includes the Program in a commercial
+product offering should do so in a manner which does not create
+potential liability for other Contributors. Therefore, if a Contributor
+includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and
+indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses")
+arising from claims, lawsuits and other legal actions brought by a third
+party against the Indemnified Contributor to the extent caused by the
+acts or omissions of such Commercial Contributor in connection with its
+distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In
+order to qualify, an Indemnified Contributor must: a) promptly notify
+the Commercial Contributor in writing of such claim, and b) allow the
+Commercial Contributor to control, and cooperate with the Commercial
+Contributor in, the defense and any related settlement negotiations. The
+Indemnified Contributor may participate in any such claim at its own
+expense.</p>
+
+<p>For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those
+performance claims and warranties, and if a court requires any other
+Contributor to pay any damages as a result, the Commercial Contributor
+must pay those damages.</p>
+
+<p><b>5. NO WARRANTY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
+PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
+ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
+OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
+responsible for determining the appropriateness of using and
+distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to
+the risks and costs of program errors, compliance with applicable laws,
+damage to or loss of data, programs or equipment, and unavailability or
+interruption of operations.</p>
+
+<p><b>6. DISCLAIMER OF LIABILITY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
+NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
+WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
+DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
+
+<p><b>7. GENERAL</b></p>
+
+<p>If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further action
+by the parties hereto, such provision shall be reformed to the minimum
+extent necessary to make such provision valid and enforceable.</p>
+
+<p>If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other
+software or hardware) infringes such Recipient's patent(s), then such
+Recipient's rights granted under Section 2(b) shall terminate as of the
+date such litigation is filed.</p>
+
+<p>All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of time
+after becoming aware of such noncompliance. If all Recipient's rights
+under this Agreement terminate, Recipient agrees to cease use and
+distribution of the Program as soon as reasonably practicable. However,
+Recipient's obligations under this Agreement and any licenses granted by
+Recipient relating to the Program shall continue and survive.</p>
+
+<p>Everyone is permitted to copy and distribute copies of this
+Agreement, but in order to avoid inconsistency the Agreement is
+copyrighted and may only be modified in the following manner. The
+Agreement Steward reserves the right to publish new versions (including
+revisions) of this Agreement from time to time. No one other than the
+Agreement Steward has the right to modify this Agreement. The Eclipse
+Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a
+suitable separate entity. Each new version of the Agreement will be
+given a distinguishing version number. The Program (including
+Contributions) may always be distributed subject to the version of the
+Agreement under which it was received. In addition, after a new version
+of the Agreement is published, Contributor may elect to distribute the
+Program (including its Contributions) under the new version. Except as
+expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
+rights or licenses to the intellectual property of any Contributor under
+this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this
+Agreement are reserved.</p>
+
+<p>This Agreement is governed by the laws of the State of New York and
+the intellectual property laws of the United States of America. No party
+to this Agreement will bring a legal action under this Agreement more
+than one year after the cause of action arose. Each party waives its
+rights to a jury trial in any resulting litigation.</p>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/jenkins.build.config.xml b/jenkins.build.config.xml
new file mode 100644
index 0000000..7866a68
--- /dev/null
+++ b/jenkins.build.config.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--#======================================================================= -->
+<!--# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) -->
+<!--# All rights reserved. This program and the accompanying materials -->
+<!--# are made available under the terms of the Eclipse Public License v1.0 -->
+<!--# which accompanies this distribution, and is available at -->
+<!--# http://www.eclipse.org/legal/epl-v10.html -->
+<!--# -->
+<!--# Contributors: -->
+<!--# Loetz GmbH&Co.KG - initial API and implementation -->
+<!--#======================================================================= -->
+<!--# Module specific parameters for the Jenkins Job -->
+<!--#======================================================================= -->
+<jenkins>
+ <!-- DO NOT EDIT BELOW THIS LINE -->
+ <jenkins.build.dependencies>
+ <jenkins.build.dependency>org.eclipse.osbp.technologystack</jenkins.build.dependency>
+ </jenkins.build.dependencies>
+</jenkins>
diff --git a/notice.html b/notice.html
new file mode 100644
index 0000000..c3d34c3
--- /dev/null
+++ b/notice.html
@@ -0,0 +1,107 @@
+<?xml version="1.0" encoding="ISO-8859-1" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>April 9, 2014</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+ (COLLECTIVELY "CONTENT"). USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+ CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+ OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+ NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+ CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
+ ("EPL"). A copy of the EPL is provided with this Content and is also available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+ For purposes of the EPL, "Program" will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse Foundation source code
+ repository ("Repository") in software modules ("Modules") and made available as downloadable archives ("Downloads").</p>
+
+<ul>
+ <li>Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"), plug-in fragments ("Fragments"), and features ("Features").</li>
+ <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java™ ARchive) in a directory named "plugins".</li>
+ <li>A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material. Each Feature may be packaged as a sub-directory in a directory named "features". Within a Feature, files named "feature.xml" may contain a list of the names and version numbers of the Plug-ins
+ and/or Fragments associated with that Feature.</li>
+ <li>Features may also include other Features ("Included Features"). Within a Feature, files named "feature.xml" may contain a list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named "about.html" ("Abouts"). The terms and conditions governing Features and
+Included Features should be contained in files named "license.html" ("Feature Licenses"). Abouts and Feature Licenses may be located in any directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+ <li>The top-level (root) directory</li>
+ <li>Plug-in and Fragment directories</li>
+ <li>Inside Plug-ins and Fragments packaged as JARs</li>
+ <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
+ <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Provisioning Technology (as defined below), you must agree to a license ("Feature Update License") during the
+installation process. If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
+inform you where you can locate them. Feature Update Licenses may be found in the "license" property of files named "feature.properties" found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+ <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+ <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+ <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+ <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+ <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License, or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software, examples of which include, but are not limited to, p2 and the Eclipse
+ Update Manager ("Provisioning Technology") for the purpose of allowing users to install software, documentation, information and/or
+ other materials (collectively "Installable Software"). This capability is provided with the intent of allowing such users to
+ install, extend and update Eclipse-based products. Information about packaging Installable Software is available at <a
+ href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+ ("Specification").</p>
+
+<p>You may use Provisioning Technology to allow other parties to install Installable Software. You shall be responsible for enabling the
+ applicable license agreements relating to the Installable Software to be presented to, and accepted by, the users of the Provisioning Technology
+ in accordance with the Specification. By using Provisioning Technology in such a manner and making it available in accordance with the
+ Specification, you further acknowledge your agreement to, and the acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+ <li>A series of actions may occur ("Provisioning Process") in which a user may execute the Provisioning Technology
+ on a machine ("Target Machine") with the intent of installing, extending or updating the functionality of an Eclipse-based
+ product.</li>
+ <li>During the Provisioning Process, the Provisioning Technology may cause third party Installable Software or a portion thereof to be
+ accessed and copied to the Target Machine.</li>
+ <li>Pursuant to the Specification, you will provide to the user the terms and conditions that govern the use of the Installable
+ Software ("Installable Software Agreement") and such Installable Software Agreement shall be accessed from the Target
+ Machine in accordance with the Specification. Such Installable Software Agreement must inform the user of the terms and conditions that govern
+ the Installable Software and must solicit acceptance by the end user in the manner prescribed in such Installable Software Agreement. Upon such
+ indication of agreement by the user, the provisioning Technology will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
+ another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
+ possession, or use, and re-export of encryption software, to see if this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/.project b/org.eclipse.osbp.xtext.oxtype.feature/.project
new file mode 100644
index 0000000..d55223b
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/.project
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>org.eclipse.osbp.xtext.oxtype.feature</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.pde.FeatureBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.m2e.core.maven2Builder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.sonarlint.eclipse.core.sonarlintBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+ <nature>org.eclipse.m2e.core.maven2Nature</nature>
+ <nature>org.eclipse.pde.FeatureNature</nature>
+ </natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/LICENSE.txt b/org.eclipse.osbp.xtext.oxtype.feature/LICENSE.txt
new file mode 100644
index 0000000..ff42ad4
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/LICENSE.txt
@@ -0,0 +1,161 @@
+Eclipse Public License -v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION
+OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and
+
+b) in the case of each subsequent Contributor:
+
+i) changes to the Program, and
+
+ii) additions to the Program;
+
+where such changes and/or additions to the Program originate from and are distributed by that particular Contributor.
+A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone
+acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate
+modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not
+derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents " mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of
+its Contribution alone or when combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement, including all Contributors.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute
+and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code
+form.
+
+b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the
+Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the
+combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such
+addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not
+apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no
+assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property
+rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity
+based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and
+licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property
+rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the
+Program, it is Recipient's responsibility to acquire that license before distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to
+grant the copyright license set forth in this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:
+
+a) it complies with the terms and conditions of this Agreement; and
+
+b) its license agreement:
+
+i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including
+warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and
+fitness for a particular purpose;
+
+ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;
+
+iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any
+other party; and
+
+iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it
+in a reasonable manner on or through a medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+a) it must be made available under this Agreement; and
+
+b) a copy of this Agreement must be included with each copy of the Program.
+
+Contributors may not remove or alter any copyright notices contained within the Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows
+subsequent Recipients to identify the originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and
+the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes
+the Program in a commercial product offering should do so in a manner which does not create potential liability for
+other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions
+brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual
+property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the
+Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may
+ participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is
+then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties
+related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone.
+Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to
+those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result,
+the Commercial Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for
+determining the appropriateness of using and distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to the risks and costs of program errors, compliance
+with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or
+enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such
+provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such
+Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or
+conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such
+noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution
+of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses
+ granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement
+is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish
+new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the
+right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the
+Agreement will be given a distinguishing version number. The Program (including Contributions) may always be
+distributed subject to the version of the Agreement under which it was received. In addition, after a new version of
+the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the
+new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
+the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States
+of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause
+of action arose. Each party waives its rights to a jury trial in any resulting litigation.
\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/build.properties b/org.eclipse.osbp.xtext.oxtype.feature/build.properties
new file mode 100644
index 0000000..0ea4044
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/build.properties
@@ -0,0 +1,10 @@
+bin.includes = feature.xml,\
+ feature.properties,\
+ notice.html,\
+ license.html,\
+ LICENSE.txt,\
+ epl-v10.html
+src.includes = license.html,\
+ LICENSE.txt,\
+ notice.html,\
+ epl-v10.html
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/epl-v10.html b/org.eclipse.osbp.xtext.oxtype.feature/epl-v10.html
new file mode 100644
index 0000000..b398acc
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/epl-v10.html
@@ -0,0 +1,259 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Public License - Version 1.0</title>
+<style type="text/css">
+ body {
+ size: 8.5in 11.0in;
+ margin: 0.25in 0.5in 0.25in 0.5in;
+ tab-interval: 0.5in;
+ }
+ p {
+ margin-left: auto;
+ margin-top: 0.5em;
+ margin-bottom: 0.5em;
+ }
+ p.list {
+ margin-left: 0.5in;
+ margin-top: 0.05em;
+ margin-bottom: 0.05em;
+ }
+ </style>
+
+</head>
+
+<body lang="EN-US">
+
+<h2>Eclipse Public License - v 1.0</h2>
+
+<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
+DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
+AGREEMENT.</p>
+
+<p><b>1. DEFINITIONS</b></p>
+
+<p>"Contribution" means:</p>
+
+<p class="list">a) in the case of the initial Contributor, the initial
+code and documentation distributed under this Agreement, and</p>
+<p class="list">b) in the case of each subsequent Contributor:</p>
+<p class="list">i) changes to the Program, and</p>
+<p class="list">ii) additions to the Program;</p>
+<p class="list">where such changes and/or additions to the Program
+originate from and are distributed by that particular Contributor. A
+Contribution 'originates' from a Contributor if it was added to the
+Program by such Contributor itself or anyone acting on such
+Contributor's behalf. Contributions do not include additions to the
+Program which: (i) are separate modules of software distributed in
+conjunction with the Program under their own license agreement, and (ii)
+are not derivative works of the Program.</p>
+
+<p>"Contributor" means any person or entity that distributes
+the Program.</p>
+
+<p>"Licensed Patents" mean patent claims licensable by a
+Contributor which are necessarily infringed by the use or sale of its
+Contribution alone or when combined with the Program.</p>
+
+<p>"Program" means the Contributions distributed in accordance
+with this Agreement.</p>
+
+<p>"Recipient" means anyone who receives the Program under
+this Agreement, including all Contributors.</p>
+
+<p><b>2. GRANT OF RIGHTS</b></p>
+
+<p class="list">a) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works
+of, publicly display, publicly perform, distribute and sublicense the
+Contribution of such Contributor, if any, and such derivative works, in
+source code and object code form.</p>
+
+<p class="list">b) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell,
+offer to sell, import and otherwise transfer the Contribution of such
+Contributor, if any, in source code and object code form. This patent
+license shall apply to the combination of the Contribution and the
+Program if, at the time the Contribution is added by the Contributor,
+such addition of the Contribution causes such combination to be covered
+by the Licensed Patents. The patent license shall not apply to any other
+combinations which include the Contribution. No hardware per se is
+licensed hereunder.</p>
+
+<p class="list">c) Recipient understands that although each Contributor
+grants the licenses to its Contributions set forth herein, no assurances
+are provided by any Contributor that the Program does not infringe the
+patent or other intellectual property rights of any other entity. Each
+Contributor disclaims any liability to Recipient for claims brought by
+any other entity based on infringement of intellectual property rights
+or otherwise. As a condition to exercising the rights and licenses
+granted hereunder, each Recipient hereby assumes sole responsibility to
+secure any other intellectual property rights needed, if any. For
+example, if a third party patent license is required to allow Recipient
+to distribute the Program, it is Recipient's responsibility to acquire
+that license before distributing the Program.</p>
+
+<p class="list">d) Each Contributor represents that to its knowledge it
+has sufficient copyright rights in its Contribution, if any, to grant
+the copyright license set forth in this Agreement.</p>
+
+<p><b>3. REQUIREMENTS</b></p>
+
+<p>A Contributor may choose to distribute the Program in object code
+form under its own license agreement, provided that:</p>
+
+<p class="list">a) it complies with the terms and conditions of this
+Agreement; and</p>
+
+<p class="list">b) its license agreement:</p>
+
+<p class="list">i) effectively disclaims on behalf of all Contributors
+all warranties and conditions, express and implied, including warranties
+or conditions of title and non-infringement, and implied warranties or
+conditions of merchantability and fitness for a particular purpose;</p>
+
+<p class="list">ii) effectively excludes on behalf of all Contributors
+all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;</p>
+
+<p class="list">iii) states that any provisions which differ from this
+Agreement are offered by that Contributor alone and not by any other
+party; and</p>
+
+<p class="list">iv) states that source code for the Program is available
+from such Contributor, and informs licensees how to obtain it in a
+reasonable manner on or through a medium customarily used for software
+exchange.</p>
+
+<p>When the Program is made available in source code form:</p>
+
+<p class="list">a) it must be made available under this Agreement; and</p>
+
+<p class="list">b) a copy of this Agreement must be included with each
+copy of the Program.</p>
+
+<p>Contributors may not remove or alter any copyright notices contained
+within the Program.</p>
+
+<p>Each Contributor must identify itself as the originator of its
+Contribution, if any, in a manner that reasonably allows subsequent
+Recipients to identify the originator of the Contribution.</p>
+
+<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
+
+<p>Commercial distributors of software may accept certain
+responsibilities with respect to end users, business partners and the
+like. While this license is intended to facilitate the commercial use of
+the Program, the Contributor who includes the Program in a commercial
+product offering should do so in a manner which does not create
+potential liability for other Contributors. Therefore, if a Contributor
+includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and
+indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses")
+arising from claims, lawsuits and other legal actions brought by a third
+party against the Indemnified Contributor to the extent caused by the
+acts or omissions of such Commercial Contributor in connection with its
+distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In
+order to qualify, an Indemnified Contributor must: a) promptly notify
+the Commercial Contributor in writing of such claim, and b) allow the
+Commercial Contributor to control, and cooperate with the Commercial
+Contributor in, the defense and any related settlement negotiations. The
+Indemnified Contributor may participate in any such claim at its own
+expense.</p>
+
+<p>For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those
+performance claims and warranties, and if a court requires any other
+Contributor to pay any damages as a result, the Commercial Contributor
+must pay those damages.</p>
+
+<p><b>5. NO WARRANTY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
+PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
+ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
+OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
+responsible for determining the appropriateness of using and
+distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to
+the risks and costs of program errors, compliance with applicable laws,
+damage to or loss of data, programs or equipment, and unavailability or
+interruption of operations.</p>
+
+<p><b>6. DISCLAIMER OF LIABILITY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
+NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
+WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
+DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
+
+<p><b>7. GENERAL</b></p>
+
+<p>If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further action
+by the parties hereto, such provision shall be reformed to the minimum
+extent necessary to make such provision valid and enforceable.</p>
+
+<p>If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other
+software or hardware) infringes such Recipient's patent(s), then such
+Recipient's rights granted under Section 2(b) shall terminate as of the
+date such litigation is filed.</p>
+
+<p>All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of time
+after becoming aware of such noncompliance. If all Recipient's rights
+under this Agreement terminate, Recipient agrees to cease use and
+distribution of the Program as soon as reasonably practicable. However,
+Recipient's obligations under this Agreement and any licenses granted by
+Recipient relating to the Program shall continue and survive.</p>
+
+<p>Everyone is permitted to copy and distribute copies of this
+Agreement, but in order to avoid inconsistency the Agreement is
+copyrighted and may only be modified in the following manner. The
+Agreement Steward reserves the right to publish new versions (including
+revisions) of this Agreement from time to time. No one other than the
+Agreement Steward has the right to modify this Agreement. The Eclipse
+Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a
+suitable separate entity. Each new version of the Agreement will be
+given a distinguishing version number. The Program (including
+Contributions) may always be distributed subject to the version of the
+Agreement under which it was received. In addition, after a new version
+of the Agreement is published, Contributor may elect to distribute the
+Program (including its Contributions) under the new version. Except as
+expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
+rights or licenses to the intellectual property of any Contributor under
+this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this
+Agreement are reserved.</p>
+
+<p>This Agreement is governed by the laws of the State of New York and
+the intellectual property laws of the United States of America. No party
+to this Agreement will bring a legal action under this Agreement more
+than one year after the cause of action arose. Each party waives its
+rights to a jury trial in any resulting litigation.</p>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/feature.properties b/org.eclipse.osbp.xtext.oxtype.feature/feature.properties
new file mode 100644
index 0000000..2fef760
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/feature.properties
@@ -0,0 +1,172 @@
+#=======================================================================
+# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany).
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+# Loetz GmbH&Co.KG - initial API and implementation
+#=======================================================================
+# feature.properties
+# contains externalized strings for feature.xml
+# "%foo" in feature.xml corresponds to the key "foo" in this file
+# java.io.Properties file (ISO 8859-1 with "\" escapes)
+# This file should be translated.
+
+# "featureName" property - name of the feature
+featureName =OSBP xtext.oxtype
+
+# "providerName" property - name of the company that provides the feature
+providerName=Eclipse OSBP
+
+# "description" property - description of the feature
+description=This feature provides the OSBP xtext.oxtype bundle.
+
+# "updateSiteName" property - label for the update site
+updateSiteName=
+
+# "copyright" property - text of the "Feature Update Copyright"
+copyright=\
+Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany). \n\
+All rights reserved. This program and the accompanying materials\n\
+are made available under the terms of the Eclipse Public License v1.0\n\
+which accompanies this distribution, and is available at\n\
+http://www.eclipse.org/legal/epl-v10.html\n\
+\n\
+Contributors:\n\
+ Loetz GmbH&Co.KG - initial API and basis\n\
+
+################ end of copyright property ####################################
+
+# "licenseURL" property - URL of the "Feature License"
+# do not translate value - just change to point to a locale-specific HTML page
+licenseURL=license.html
+
+# "license" property - text of the "Feature Update License"
+# should be plain text version of license agreement pointed to be "licenseURL"
+license=\
+Eclipse Foundation Software User Agreement\n\
+February 1, 2011\n\
+\n\
+Usage Of Content\n\
+\n\
+THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
+OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
+USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
+AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
+NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU\n\
+AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
+AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
+OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
+TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
+OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
+BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
+\n\
+Applicable Licenses\n\
+\n\
+Unless otherwise indicated, all Content made available by the\n\
+Eclipse Foundation is provided to you under the terms and conditions of\n\
+the Eclipse Public License Version 1.0 ("EPL"). A copy of the EPL is\n\
+provided with this Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
+For purposes of the EPL, "Program" will mean the Content.\n\
+\n\
+Content includes, but is not limited to, source code, object code,\n\
+documentation and other files maintained in the Eclipse Foundation source code\n\
+repository ("Repository") in software modules ("Modules") and made available\n\
+as downloadable archives ("Downloads").\n\
+\n\
+ - Content may be structured and packaged into modules to facilitate delivering,\n\
+ extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
+ plug-in fragments ("Fragments"), and features ("Features").\n\
+ - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java(TM) ARchive)\n\
+ in a directory named "plugins".\n\
+ - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
+ Each Feature may be packaged as a sub-directory in a directory named "features".\n\
+ Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
+ numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
+ - Features may also include other Features ("Included Features"). Within a Feature, files\n\
+ named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
+\n\
+The terms and conditions governing Plug-ins and Fragments should be\n\
+contained in files named "about.html" ("Abouts"). The terms and\n\
+conditions governing Features and Included Features should be contained\n\
+in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
+Licenses may be located in any directory of a Download or Module\n\
+including, but not limited to the following locations:\n\
+\n\
+ - The top-level (root) directory\n\
+ - Plug-in and Fragment directories\n\
+ - Inside Plug-ins and Fragments packaged as JARs\n\
+ - Sub-directories of the directory named "src" of certain Plug-ins\n\
+ - Feature directories\n\
+\n\
+Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
+Provisioning Technology (as defined below), you must agree to a license ("Feature \n\
+Update License") during the installation process. If the Feature contains\n\
+Included Features, the Feature Update License should either provide you\n\
+with the terms and conditions governing the Included Features or inform\n\
+you where you can locate them. Feature Update Licenses may be found in\n\
+the "license" property of files named "feature.properties" found within a Feature.\n\
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the\n\
+terms and conditions (or references to such terms and conditions) that\n\
+govern your use of the associated Content in that directory.\n\
+\n\
+THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER\n\
+TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
+SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
+\n\
+ - Eclipse Distribution License Version 1.0 (available at http://www.eclipse.org/licenses/edl-v1.0.html)\n\
+ - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
+ - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
+ - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
+ - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
+ - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
+\n\
+IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
+TO USE OF THE CONTENT. If no About, Feature License, or Feature Update License\n\
+is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
+govern that particular Content.\n\
+\n\
+\n\Use of Provisioning Technology\n\
+\n\
+The Eclipse Foundation makes available provisioning software, examples of which include,\n\
+but are not limited to, p2 and the Eclipse Update Manager ("Provisioning Technology") for\n\
+the purpose of allowing users to install software, documentation, information and/or\n\
+other materials (collectively "Installable Software"). This capability is provided with\n\
+the intent of allowing such users to install, extend and update Eclipse-based products.\n\
+Information about packaging Installable Software is available at\n\
+http://eclipse.org/equinox/p2/repository_packaging.html ("Specification").\n\
+\n\
+You may use Provisioning Technology to allow other parties to install Installable Software.\n\
+You shall be responsible for enabling the applicable license agreements relating to the\n\
+Installable Software to be presented to, and accepted by, the users of the Provisioning Technology\n\
+in accordance with the Specification. By using Provisioning Technology in such a manner and\n\
+making it available in accordance with the Specification, you further acknowledge your\n\
+agreement to, and the acquisition of all necessary rights to permit the following:\n\
+\n\
+ 1. A series of actions may occur ("Provisioning Process") in which a user may execute\n\
+ the Provisioning Technology on a machine ("Target Machine") with the intent of installing,\n\
+ extending or updating the functionality of an Eclipse-based product.\n\
+ 2. During the Provisioning Process, the Provisioning Technology may cause third party\n\
+ Installable Software or a portion thereof to be accessed and copied to the Target Machine.\n\
+ 3. Pursuant to the Specification, you will provide to the user the terms and conditions that\n\
+ govern the use of the Installable Software ("Installable Software Agreement") and such\n\
+ Installable Software Agreement shall be accessed from the Target Machine in accordance\n\
+ with the Specification. Such Installable Software Agreement must inform the user of the\n\
+ terms and conditions that govern the Installable Software and must solicit acceptance by\n\
+ the end user in the manner prescribed in such Installable Software Agreement. Upon such\n\
+ indication of agreement by the user, the provisioning Technology will complete installation\n\
+ of the Installable Software.\n\
+\n\
+Cryptography\n\
+\n\
+Content may contain encryption software. The country in which you are\n\
+currently may have restrictions on the import, possession, and use,\n\
+and/or re-export to another country, of encryption software. BEFORE\n\
+using any encryption software, please check the country's laws,\n\
+regulations and policies concerning the import, possession, or use, and\n\
+re-export of encryption software, to see if this is permitted.\n\
+\n\
+Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.\n
+########### end of license property ##########################################
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/feature.xml b/org.eclipse.osbp.xtext.oxtype.feature/feature.xml
new file mode 100644
index 0000000..3352960
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/feature.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feature
+ id="org.eclipse.osbp.xtext.oxtype.feature"
+ label="%featureName"
+ version="0.9.0.qualifier"
+ provider-name="%providerName">
+
+ <description>
+ %description
+ </description>
+
+ <copyright>
+ %copyright
+ </copyright>
+
+ <license url="%licenseURL">
+ %license
+ </license>
+
+ <plugin
+ id="org.eclipse.osbp.xtext.oxtype"
+ download-size="0"
+ install-size="0"
+ version="0.0.0"
+ unpack="false"/>
+
+
+
+</feature>
\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/license.html b/org.eclipse.osbp.xtext.oxtype.feature/license.html
new file mode 100644
index 0000000..6e579a5
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/license.html
@@ -0,0 +1,164 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>February 1, 2011</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+ (COLLECTIVELY "CONTENT"). USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+ CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+ OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+ NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+ CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse
+ Foundation is provided to you under the terms and conditions of the
+Eclipse Public License Version 1.0
+ ("EPL"). A copy of the EPL is provided with this Content and is also
+ available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+ For purposes of the EPL, "Program" will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code,
+documentation and other files maintained in the Eclipse Foundation
+source code
+ repository ("Repository") in software modules ("Modules") and made
+available as downloadable archives ("Downloads").</p>
+
+<ul>
+ <li>Content may be structured and packaged into modules to
+facilitate delivering, extending, and upgrading the Content. Typical
+modules may include plug-ins ("Plug-ins"), plug-in fragments
+("Fragments"), and features ("Features").</li>
+ <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java™ ARchive) in a directory named "plugins".</li>
+ <li>A Feature is a bundle of one or more Plug-ins and/or
+Fragments and associated material. Each Feature may be packaged as a
+sub-directory in a directory named "features". Within a Feature, files
+named "feature.xml" may contain a list of the names and version numbers
+of the Plug-ins
+ and/or Fragments associated with that Feature.</li>
+ <li>Features may also include other Features ("Included
+Features"). Within a Feature, files named "feature.xml" may contain a
+list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be
+contained in files named "about.html" ("Abouts"). The terms and
+conditions governing Features and
+Included Features should be contained in files named "license.html"
+("Feature Licenses"). Abouts and Feature Licenses may be located in any
+ directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+ <li>The top-level (root) directory</li>
+ <li>Plug-in and Fragment directories</li>
+ <li>Inside Plug-ins and Fragments packaged as JARs</li>
+ <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
+ <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is
+installed using the Provisioning Technology (as defined below), you must
+ agree to a license ("Feature Update License") during the
+installation process. If the Feature contains Included Features, the
+Feature Update License should either provide you with the terms and
+conditions governing the Included Features or
+inform you where you can locate them. Feature Update Licenses may be
+found in the "license" property of files named "feature.properties"
+found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the
+terms and conditions (or references to such terms and conditions) that
+govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER
+TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
+ SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+ <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+ <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+ <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+ <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+ <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
+ <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions
+govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software,
+examples of which include, but are not limited to, p2 and the Eclipse
+ Update Manager ("Provisioning Technology") for the purpose of
+allowing users to install software, documentation, information and/or
+ other materials (collectively "Installable Software"). This
+capability is provided with the intent of allowing such users to
+ install, extend and update Eclipse-based products. Information about
+packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+ ("Specification").</p>
+
+<p>You may use Provisioning Technology to allow other parties to install
+ Installable Software. You shall be responsible for enabling the
+ applicable license agreements relating to the Installable Software to
+ be presented to, and accepted by, the users of the Provisioning
+Technology
+ in accordance with the Specification. By using Provisioning
+Technology in such a manner and making it available in accordance with
+the
+ Specification, you further acknowledge your agreement to, and the
+acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+ <li>A series of actions may occur ("Provisioning Process") in
+which a user may execute the Provisioning Technology
+ on a machine ("Target Machine") with the intent of installing,
+extending or updating the functionality of an Eclipse-based
+ product.</li>
+ <li>During the Provisioning Process, the Provisioning Technology
+may cause third party Installable Software or a portion thereof to be
+ accessed and copied to the Target Machine.</li>
+ <li>Pursuant to the Specification, you will provide to the user
+the terms and conditions that govern the use of the Installable
+ Software ("Installable Software Agreement") and such Installable
+Software Agreement shall be accessed from the Target
+ Machine in accordance with the Specification. Such Installable
+Software Agreement must inform the user of the terms and conditions that
+ govern
+ the Installable Software and must solicit acceptance by the end
+user in the manner prescribed in such Installable Software Agreement.
+Upon such
+ indication of agreement by the user, the provisioning Technology
+will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are
+ currently may have restrictions on the import, possession, and use,
+and/or re-export to
+ another country, of encryption software. BEFORE using any encryption
+software, please check the country's laws, regulations and policies
+concerning the import,
+ possession, or use, and re-export of encryption software, to see if
+this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+
+
+</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/notice.html b/org.eclipse.osbp.xtext.oxtype.feature/notice.html
new file mode 100644
index 0000000..c3d34c3
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/notice.html
@@ -0,0 +1,107 @@
+<?xml version="1.0" encoding="ISO-8859-1" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>April 9, 2014</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+ (COLLECTIVELY "CONTENT"). USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+ CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+ OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+ NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+ CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
+ ("EPL"). A copy of the EPL is provided with this Content and is also available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+ For purposes of the EPL, "Program" will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse Foundation source code
+ repository ("Repository") in software modules ("Modules") and made available as downloadable archives ("Downloads").</p>
+
+<ul>
+ <li>Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"), plug-in fragments ("Fragments"), and features ("Features").</li>
+ <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java™ ARchive) in a directory named "plugins".</li>
+ <li>A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material. Each Feature may be packaged as a sub-directory in a directory named "features". Within a Feature, files named "feature.xml" may contain a list of the names and version numbers of the Plug-ins
+ and/or Fragments associated with that Feature.</li>
+ <li>Features may also include other Features ("Included Features"). Within a Feature, files named "feature.xml" may contain a list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named "about.html" ("Abouts"). The terms and conditions governing Features and
+Included Features should be contained in files named "license.html" ("Feature Licenses"). Abouts and Feature Licenses may be located in any directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+ <li>The top-level (root) directory</li>
+ <li>Plug-in and Fragment directories</li>
+ <li>Inside Plug-ins and Fragments packaged as JARs</li>
+ <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
+ <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Provisioning Technology (as defined below), you must agree to a license ("Feature Update License") during the
+installation process. If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
+inform you where you can locate them. Feature Update Licenses may be found in the "license" property of files named "feature.properties" found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+ <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+ <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+ <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+ <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+ <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License, or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software, examples of which include, but are not limited to, p2 and the Eclipse
+ Update Manager ("Provisioning Technology") for the purpose of allowing users to install software, documentation, information and/or
+ other materials (collectively "Installable Software"). This capability is provided with the intent of allowing such users to
+ install, extend and update Eclipse-based products. Information about packaging Installable Software is available at <a
+ href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+ ("Specification").</p>
+
+<p>You may use Provisioning Technology to allow other parties to install Installable Software. You shall be responsible for enabling the
+ applicable license agreements relating to the Installable Software to be presented to, and accepted by, the users of the Provisioning Technology
+ in accordance with the Specification. By using Provisioning Technology in such a manner and making it available in accordance with the
+ Specification, you further acknowledge your agreement to, and the acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+ <li>A series of actions may occur ("Provisioning Process") in which a user may execute the Provisioning Technology
+ on a machine ("Target Machine") with the intent of installing, extending or updating the functionality of an Eclipse-based
+ product.</li>
+ <li>During the Provisioning Process, the Provisioning Technology may cause third party Installable Software or a portion thereof to be
+ accessed and copied to the Target Machine.</li>
+ <li>Pursuant to the Specification, you will provide to the user the terms and conditions that govern the use of the Installable
+ Software ("Installable Software Agreement") and such Installable Software Agreement shall be accessed from the Target
+ Machine in accordance with the Specification. Such Installable Software Agreement must inform the user of the terms and conditions that govern
+ the Installable Software and must solicit acceptance by the end user in the manner prescribed in such Installable Software Agreement. Upon such
+ indication of agreement by the user, the provisioning Technology will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
+ another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
+ possession, or use, and re-export of encryption software, to see if this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/pom.xml b/org.eclipse.osbp.xtext.oxtype.feature/pom.xml
new file mode 100644
index 0000000..2b8d8d8
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/pom.xml
@@ -0,0 +1,85 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+#=======================================================================
+# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany).
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+# Loetz GmbH&Co.KG - initial API and implementation
+#=======================================================================
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.eclipse.osbp.xtext.oxtype</groupId>
+ <artifactId>org.eclipse.osbp.xtext.oxtype.aggregator</artifactId>
+ <version>0.9.0-SNAPSHOT</version>
+ <relativePath>..</relativePath>
+ </parent>
+
+ <artifactId>org.eclipse.osbp.xtext.oxtype.feature</artifactId>
+ <packaging>eclipse-feature</packaging>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.eclipse.tycho.extras</groupId>
+ <artifactId>tycho-source-feature-plugin</artifactId>
+ <version>${tychoExtrasVersion}</version>
+ <executions>
+ <execution>
+ <id>source-feature</id>
+ <phase>package</phase>
+ <goals>
+ <goal>source-feature</goal>
+ </goals>
+ </execution>
+ </executions>
+ <configuration>
+ <labelSuffix> (source)</labelSuffix>
+ </configuration>
+ </plugin>
+ <plugin>
+ <!-- workaround while bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=398250
+ is not fixed -->
+ <groupId>org.eclipse.tycho</groupId>
+ <artifactId>tycho-p2-plugin</artifactId>
+ <version>${tycho-version}</version>
+ <executions>
+ <execution>
+ <id>attached-p2-metadata</id>
+ <phase>package</phase>
+ <goals>
+ <goal>p2-metadata</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <artifactId>maven-javadoc-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>javadoc-jar</id>
+ <phase>package</phase>
+ <goals>
+ <goal>jar</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.eclipse.osbp.xtext.oxtype</groupId>
+ <artifactId>org.eclipse.osbp.xtext.oxtype</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ </dependencies>
+
+</project>
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/src/main/javadoc/README.txt b/org.eclipse.osbp.xtext.oxtype.feature/src/main/javadoc/README.txt
new file mode 100644
index 0000000..831da7e
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/src/main/javadoc/README.txt
@@ -0,0 +1 @@
+Resource folder for javadoc resources.
\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/src/overview.html b/org.eclipse.osbp.xtext.oxtype.feature/src/overview.html
new file mode 100644
index 0000000..8ef8212
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/src/overview.html
@@ -0,0 +1,9 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<html>
+<head>
+ <title>OSBP xtext.oxtype</title>
+</head>
+<body>
+<p>The <strong>OSBP xtext.oxtype</strong> provides bundles for the OSBP xtext.oxtype functionality.</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/.project b/org.eclipse.osbp.xtext.oxtype.ide/.project
new file mode 100644
index 0000000..8d5c39e
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>org.eclipse.osbp.xtext.oxtype.ide</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.m2e.core.maven2Builder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <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.m2e.core.maven2Nature</nature>
+ <nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ <nature>org.eclipse.pde.PluginNature</nature>
+ </natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/META-INF/MANIFEST.MF b/org.eclipse.osbp.xtext.oxtype.ide/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..645fa2b
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/META-INF/MANIFEST.MF
@@ -0,0 +1,15 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.osbp.xtext.oxtype.ide
+Bundle-Vendor: Eclipse OSBP
+Bundle-Version: 0.9.0.qualifier
+Bundle-SymbolicName: org.eclipse.osbp.xtext.oxtype.ide; singleton:=true
+Bundle-ActivationPolicy: lazy
+Require-Bundle: org.eclipse.osbp.xtext.oxtype,
+ org.eclipse.xtext.ide,
+ org.eclipse.xtext.xbase.ide,
+ org.antlr.runtime
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Export-Package: org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr,
+ org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.internal
+
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/build.properties b/org.eclipse.osbp.xtext.oxtype.ide/build.properties
new file mode 100644
index 0000000..5c6bbf9
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/build.properties
@@ -0,0 +1,6 @@
+source.. = src/,\
+ src-gen/,\
+ xtend-gen/
+bin.includes = .,\
+ META-INF/
+bin.excludes = **/*.xtend
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/pom.xml b/org.eclipse.osbp.xtext.oxtype.ide/pom.xml
new file mode 100644
index 0000000..ee747b8
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/pom.xml
@@ -0,0 +1,22 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.eclipse.osbp.xtext.oxtype</groupId>
+ <artifactId>org.eclipse.osbp.xtext.oxtype.aggregator</artifactId>
+ <version>0.9.0-SNAPSHOT</version>
+ <relativePath>..</relativePath>
+ </parent>
+ <artifactId>org.eclipse.osbp.xtext.oxtype.ide</artifactId>
+ <packaging>eclipse-plugin</packaging>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.eclipse.xtend</groupId>
+ <artifactId>xtend-maven-plugin</artifactId>
+ </plugin>
+ </plugins>
+ </build>
+
+</project>
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src-gen/META-INF/services/org.eclipse.xtext.ISetup b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/META-INF/services/org.eclipse.xtext.ISetup
new file mode 100644
index 0000000..e989786
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/META-INF/services/org.eclipse.xtext.ISetup
@@ -0,0 +1 @@
+org.eclipse.osbp.xtext.oxtype.ide.OXtypeIdeSetup
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/AbstractOXtypeIdeModule.java b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/AbstractOXtypeIdeModule.java
new file mode 100644
index 0000000..a14a8d1
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/AbstractOXtypeIdeModule.java
@@ -0,0 +1,47 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ide;
+
+import com.google.inject.Binder;
+import com.google.inject.name.Names;
+import org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.OXtypeParser;
+import org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.internal.InternalOXtypeLexer;
+import org.eclipse.xtext.ide.LexerIdeBindings;
+import org.eclipse.xtext.ide.editor.contentassist.FQNPrefixMatcher;
+import org.eclipse.xtext.ide.editor.contentassist.IPrefixMatcher;
+import org.eclipse.xtext.ide.editor.contentassist.IProposalConflictHelper;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.AntlrProposalConflictHelper;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.IContentAssistParser;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer;
+import org.eclipse.xtext.xbase.ide.DefaultXbaseIdeModule;
+
+/**
+ * Manual modifications go to {@link OXtypeIdeModule}.
+ */
+@SuppressWarnings("all")
+public abstract class AbstractOXtypeIdeModule extends DefaultXbaseIdeModule {
+
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public void configureContentAssistLexer(Binder binder) {
+ binder.bind(Lexer.class)
+ .annotatedWith(Names.named(LexerIdeBindings.CONTENT_ASSIST))
+ .to(InternalOXtypeLexer.class);
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public Class<? extends IContentAssistParser> bindIContentAssistParser() {
+ return OXtypeParser.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public Class<? extends IProposalConflictHelper> bindIProposalConflictHelper() {
+ return AntlrProposalConflictHelper.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.exporting.QualifiedNamesFragment2
+ public Class<? extends IPrefixMatcher> bindIPrefixMatcher() {
+ return FQNPrefixMatcher.class;
+ }
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/OXtypeParser.java b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/OXtypeParser.java
new file mode 100644
index 0000000..0e7d28b
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/OXtypeParser.java
@@ -0,0 +1,452 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr;
+
+import com.google.inject.Inject;
+import java.util.HashMap;
+import java.util.Map;
+import org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.internal.InternalOXtypeParser;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+import org.eclipse.xtext.AbstractElement;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.AbstractContentAssistParser;
+
+public class OXtypeParser extends AbstractContentAssistParser {
+
+ @Inject
+ private OXtypeGrammarAccess grammarAccess;
+
+ private Map<AbstractElement, String> nameMappings;
+
+ @Override
+ protected InternalOXtypeParser createParser() {
+ InternalOXtypeParser result = new InternalOXtypeParser(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.getXImportDeclarationAccess().getAlternatives_2(), "rule__XImportDeclaration__Alternatives_2");
+ put(grammarAccess.getXImportDeclarationAccess().getAlternatives_2_0_3(), "rule__XImportDeclaration__Alternatives_2_0_3");
+ put(grammarAccess.getXAnnotationAccess().getAlternatives_3_1(), "rule__XAnnotation__Alternatives_3_1");
+ put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getAlternatives(), "rule__XAnnotationElementValueOrCommaList__Alternatives");
+ put(grammarAccess.getXAnnotationElementValueAccess().getAlternatives(), "rule__XAnnotationElementValue__Alternatives");
+ put(grammarAccess.getXAnnotationOrExpressionAccess().getAlternatives(), "rule__XAnnotationOrExpression__Alternatives");
+ put(grammarAccess.getXAssignmentAccess().getAlternatives(), "rule__XAssignment__Alternatives");
+ put(grammarAccess.getOpMultiAssignAccess().getAlternatives(), "rule__OpMultiAssign__Alternatives");
+ put(grammarAccess.getOpEqualityAccess().getAlternatives(), "rule__OpEquality__Alternatives");
+ put(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1(), "rule__XRelationalExpression__Alternatives_1");
+ put(grammarAccess.getOpCompareAccess().getAlternatives(), "rule__OpCompare__Alternatives");
+ put(grammarAccess.getOpOtherAccess().getAlternatives(), "rule__OpOther__Alternatives");
+ put(grammarAccess.getOpOtherAccess().getAlternatives_5_1(), "rule__OpOther__Alternatives_5_1");
+ put(grammarAccess.getOpOtherAccess().getAlternatives_6_1(), "rule__OpOther__Alternatives_6_1");
+ put(grammarAccess.getOpAddAccess().getAlternatives(), "rule__OpAdd__Alternatives");
+ put(grammarAccess.getOpMultiAccess().getAlternatives(), "rule__OpMulti__Alternatives");
+ put(grammarAccess.getXUnaryOperationAccess().getAlternatives(), "rule__XUnaryOperation__Alternatives");
+ put(grammarAccess.getOpUnaryAccess().getAlternatives(), "rule__OpUnary__Alternatives");
+ put(grammarAccess.getOpPostfixAccess().getAlternatives(), "rule__OpPostfix__Alternatives");
+ put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1(), "rule__XMemberFeatureCall__Alternatives_1");
+ put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1(), "rule__XMemberFeatureCall__Alternatives_1_0_0_0_1");
+ put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1(), "rule__XMemberFeatureCall__Alternatives_1_1_0_0_1");
+ put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1(), "rule__XMemberFeatureCall__Alternatives_1_1_3_1");
+ put(grammarAccess.getXPrimaryExpressionAccess().getAlternatives(), "rule__XPrimaryExpression__Alternatives");
+ put(grammarAccess.getXLiteralAccess().getAlternatives(), "rule__XLiteral__Alternatives");
+ put(grammarAccess.getXCollectionLiteralAccess().getAlternatives(), "rule__XCollectionLiteral__Alternatives");
+ put(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2(), "rule__XSwitchExpression__Alternatives_2");
+ put(grammarAccess.getXCasePartAccess().getAlternatives_3(), "rule__XCasePart__Alternatives_3");
+ put(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives(), "rule__XExpressionOrVarDeclaration__Alternatives");
+ put(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1(), "rule__XVariableDeclaration__Alternatives_1");
+ put(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2(), "rule__XVariableDeclaration__Alternatives_2");
+ put(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1(), "rule__XFeatureCall__Alternatives_3_1");
+ put(grammarAccess.getFeatureCallIDAccess().getAlternatives(), "rule__FeatureCallID__Alternatives");
+ put(grammarAccess.getIdOrSuperAccess().getAlternatives(), "rule__IdOrSuper__Alternatives");
+ put(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1(), "rule__XConstructorCall__Alternatives_4_1");
+ put(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1(), "rule__XBooleanLiteral__Alternatives_1");
+ put(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3(), "rule__XTryCatchFinallyExpression__Alternatives_3");
+ put(grammarAccess.getNumberAccess().getAlternatives(), "rule__Number__Alternatives");
+ put(grammarAccess.getNumberAccess().getAlternatives_1_0(), "rule__Number__Alternatives_1_0");
+ put(grammarAccess.getNumberAccess().getAlternatives_1_1_1(), "rule__Number__Alternatives_1_1_1");
+ put(grammarAccess.getJvmTypeReferenceAccess().getAlternatives(), "rule__JvmTypeReference__Alternatives");
+ put(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives(), "rule__JvmArgumentTypeReference__Alternatives");
+ put(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2(), "rule__JvmWildcardTypeReference__Alternatives_2");
+ put(grammarAccess.getXImportDeclarationAccess().getGroup(), "rule__XImportDeclaration__Group__0");
+ put(grammarAccess.getXImportDeclarationAccess().getGroup_2_0(), "rule__XImportDeclaration__Group_2_0__0");
+ put(grammarAccess.getXImportDeclarationAccess().getGroup_2_3(), "rule__XImportDeclaration__Group_2_3__0");
+ put(grammarAccess.getXAnnotationAccess().getGroup(), "rule__XAnnotation__Group__0");
+ put(grammarAccess.getXAnnotationAccess().getGroup_3(), "rule__XAnnotation__Group_3__0");
+ put(grammarAccess.getXAnnotationAccess().getGroup_3_1_0(), "rule__XAnnotation__Group_3_1_0__0");
+ put(grammarAccess.getXAnnotationAccess().getGroup_3_1_0_1(), "rule__XAnnotation__Group_3_1_0_1__0");
+ put(grammarAccess.getXAnnotationElementValuePairAccess().getGroup(), "rule__XAnnotationElementValuePair__Group__0");
+ put(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0(), "rule__XAnnotationElementValuePair__Group_0__0");
+ put(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0_0(), "rule__XAnnotationElementValuePair__Group_0_0__0");
+ put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0(), "rule__XAnnotationElementValueOrCommaList__Group_0__0");
+ put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0(), "rule__XAnnotationElementValueOrCommaList__Group_0_0__0");
+ put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0_0(), "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0");
+ put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1(), "rule__XAnnotationElementValueOrCommaList__Group_0_1__0");
+ put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1_1(), "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0");
+ put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1(), "rule__XAnnotationElementValueOrCommaList__Group_1__0");
+ put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1(), "rule__XAnnotationElementValueOrCommaList__Group_1_1__0");
+ put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1(), "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0");
+ put(grammarAccess.getXAnnotationElementValueAccess().getGroup_0(), "rule__XAnnotationElementValue__Group_0__0");
+ put(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0(), "rule__XAnnotationElementValue__Group_0_0__0");
+ put(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0_0(), "rule__XAnnotationElementValue__Group_0_0_0__0");
+ put(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1(), "rule__XAnnotationElementValue__Group_0_1__0");
+ put(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1_1(), "rule__XAnnotationElementValue__Group_0_1_1__0");
+ put(grammarAccess.getXAssignmentAccess().getGroup_0(), "rule__XAssignment__Group_0__0");
+ put(grammarAccess.getXAssignmentAccess().getGroup_1(), "rule__XAssignment__Group_1__0");
+ put(grammarAccess.getXAssignmentAccess().getGroup_1_1(), "rule__XAssignment__Group_1_1__0");
+ put(grammarAccess.getXAssignmentAccess().getGroup_1_1_0(), "rule__XAssignment__Group_1_1_0__0");
+ put(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0(), "rule__XAssignment__Group_1_1_0_0__0");
+ put(grammarAccess.getOpMultiAssignAccess().getGroup_5(), "rule__OpMultiAssign__Group_5__0");
+ put(grammarAccess.getOpMultiAssignAccess().getGroup_6(), "rule__OpMultiAssign__Group_6__0");
+ put(grammarAccess.getXOrExpressionAccess().getGroup(), "rule__XOrExpression__Group__0");
+ put(grammarAccess.getXOrExpressionAccess().getGroup_1(), "rule__XOrExpression__Group_1__0");
+ put(grammarAccess.getXOrExpressionAccess().getGroup_1_0(), "rule__XOrExpression__Group_1_0__0");
+ put(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0(), "rule__XOrExpression__Group_1_0_0__0");
+ put(grammarAccess.getXAndExpressionAccess().getGroup(), "rule__XAndExpression__Group__0");
+ put(grammarAccess.getXAndExpressionAccess().getGroup_1(), "rule__XAndExpression__Group_1__0");
+ put(grammarAccess.getXAndExpressionAccess().getGroup_1_0(), "rule__XAndExpression__Group_1_0__0");
+ put(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0(), "rule__XAndExpression__Group_1_0_0__0");
+ put(grammarAccess.getXEqualityExpressionAccess().getGroup(), "rule__XEqualityExpression__Group__0");
+ put(grammarAccess.getXEqualityExpressionAccess().getGroup_1(), "rule__XEqualityExpression__Group_1__0");
+ put(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0(), "rule__XEqualityExpression__Group_1_0__0");
+ put(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0(), "rule__XEqualityExpression__Group_1_0_0__0");
+ put(grammarAccess.getXRelationalExpressionAccess().getGroup(), "rule__XRelationalExpression__Group__0");
+ put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0(), "rule__XRelationalExpression__Group_1_0__0");
+ put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0(), "rule__XRelationalExpression__Group_1_0_0__0");
+ put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0(), "rule__XRelationalExpression__Group_1_0_0_0__0");
+ put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1(), "rule__XRelationalExpression__Group_1_1__0");
+ put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0(), "rule__XRelationalExpression__Group_1_1_0__0");
+ put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0(), "rule__XRelationalExpression__Group_1_1_0_0__0");
+ put(grammarAccess.getOpCompareAccess().getGroup_1(), "rule__OpCompare__Group_1__0");
+ put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup(), "rule__XOtherOperatorExpression__Group__0");
+ put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1(), "rule__XOtherOperatorExpression__Group_1__0");
+ put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0(), "rule__XOtherOperatorExpression__Group_1_0__0");
+ put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0(), "rule__XOtherOperatorExpression__Group_1_0_0__0");
+ put(grammarAccess.getOpOtherAccess().getGroup_2(), "rule__OpOther__Group_2__0");
+ put(grammarAccess.getOpOtherAccess().getGroup_5(), "rule__OpOther__Group_5__0");
+ put(grammarAccess.getOpOtherAccess().getGroup_5_1_0(), "rule__OpOther__Group_5_1_0__0");
+ put(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0(), "rule__OpOther__Group_5_1_0_0__0");
+ put(grammarAccess.getOpOtherAccess().getGroup_6(), "rule__OpOther__Group_6__0");
+ put(grammarAccess.getOpOtherAccess().getGroup_6_1_0(), "rule__OpOther__Group_6_1_0__0");
+ put(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0(), "rule__OpOther__Group_6_1_0_0__0");
+ put(grammarAccess.getXAdditiveExpressionAccess().getGroup(), "rule__XAdditiveExpression__Group__0");
+ put(grammarAccess.getXAdditiveExpressionAccess().getGroup_1(), "rule__XAdditiveExpression__Group_1__0");
+ put(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0(), "rule__XAdditiveExpression__Group_1_0__0");
+ put(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0(), "rule__XAdditiveExpression__Group_1_0_0__0");
+ put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup(), "rule__XMultiplicativeExpression__Group__0");
+ put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1(), "rule__XMultiplicativeExpression__Group_1__0");
+ put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0(), "rule__XMultiplicativeExpression__Group_1_0__0");
+ put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0(), "rule__XMultiplicativeExpression__Group_1_0_0__0");
+ put(grammarAccess.getXUnaryOperationAccess().getGroup_0(), "rule__XUnaryOperation__Group_0__0");
+ put(grammarAccess.getXCastedExpressionAccess().getGroup(), "rule__XCastedExpression__Group__0");
+ put(grammarAccess.getXCastedExpressionAccess().getGroup_1(), "rule__XCastedExpression__Group_1__0");
+ put(grammarAccess.getXCastedExpressionAccess().getGroup_1_0(), "rule__XCastedExpression__Group_1_0__0");
+ put(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0(), "rule__XCastedExpression__Group_1_0_0__0");
+ put(grammarAccess.getXPostfixOperationAccess().getGroup(), "rule__XPostfixOperation__Group__0");
+ put(grammarAccess.getXPostfixOperationAccess().getGroup_1(), "rule__XPostfixOperation__Group_1__0");
+ put(grammarAccess.getXPostfixOperationAccess().getGroup_1_0(), "rule__XPostfixOperation__Group_1_0__0");
+ put(grammarAccess.getXMemberFeatureCallAccess().getGroup(), "rule__XMemberFeatureCall__Group__0");
+ put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0(), "rule__XMemberFeatureCall__Group_1_0__0");
+ put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0(), "rule__XMemberFeatureCall__Group_1_0_0__0");
+ put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0(), "rule__XMemberFeatureCall__Group_1_0_0_0__0");
+ put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1(), "rule__XMemberFeatureCall__Group_1_1__0");
+ put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0(), "rule__XMemberFeatureCall__Group_1_1_0__0");
+ put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0(), "rule__XMemberFeatureCall__Group_1_1_0_0__0");
+ put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1(), "rule__XMemberFeatureCall__Group_1_1_1__0");
+ put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2(), "rule__XMemberFeatureCall__Group_1_1_1_2__0");
+ put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3(), "rule__XMemberFeatureCall__Group_1_1_3__0");
+ put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1(), "rule__XMemberFeatureCall__Group_1_1_3_1_1__0");
+ put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1(), "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0");
+ put(grammarAccess.getXSetLiteralAccess().getGroup(), "rule__XSetLiteral__Group__0");
+ put(grammarAccess.getXSetLiteralAccess().getGroup_3(), "rule__XSetLiteral__Group_3__0");
+ put(grammarAccess.getXSetLiteralAccess().getGroup_3_1(), "rule__XSetLiteral__Group_3_1__0");
+ put(grammarAccess.getXListLiteralAccess().getGroup(), "rule__XListLiteral__Group__0");
+ put(grammarAccess.getXListLiteralAccess().getGroup_3(), "rule__XListLiteral__Group_3__0");
+ put(grammarAccess.getXListLiteralAccess().getGroup_3_1(), "rule__XListLiteral__Group_3_1__0");
+ put(grammarAccess.getXClosureAccess().getGroup(), "rule__XClosure__Group__0");
+ put(grammarAccess.getXClosureAccess().getGroup_0(), "rule__XClosure__Group_0__0");
+ put(grammarAccess.getXClosureAccess().getGroup_0_0(), "rule__XClosure__Group_0_0__0");
+ put(grammarAccess.getXClosureAccess().getGroup_1(), "rule__XClosure__Group_1__0");
+ put(grammarAccess.getXClosureAccess().getGroup_1_0(), "rule__XClosure__Group_1_0__0");
+ put(grammarAccess.getXClosureAccess().getGroup_1_0_0(), "rule__XClosure__Group_1_0_0__0");
+ put(grammarAccess.getXClosureAccess().getGroup_1_0_0_1(), "rule__XClosure__Group_1_0_0_1__0");
+ put(grammarAccess.getXExpressionInClosureAccess().getGroup(), "rule__XExpressionInClosure__Group__0");
+ put(grammarAccess.getXExpressionInClosureAccess().getGroup_1(), "rule__XExpressionInClosure__Group_1__0");
+ put(grammarAccess.getXShortClosureAccess().getGroup(), "rule__XShortClosure__Group__0");
+ put(grammarAccess.getXShortClosureAccess().getGroup_0(), "rule__XShortClosure__Group_0__0");
+ put(grammarAccess.getXShortClosureAccess().getGroup_0_0(), "rule__XShortClosure__Group_0_0__0");
+ put(grammarAccess.getXShortClosureAccess().getGroup_0_0_1(), "rule__XShortClosure__Group_0_0_1__0");
+ put(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1(), "rule__XShortClosure__Group_0_0_1_1__0");
+ put(grammarAccess.getXParenthesizedExpressionAccess().getGroup(), "rule__XParenthesizedExpression__Group__0");
+ put(grammarAccess.getXIfExpressionAccess().getGroup(), "rule__XIfExpression__Group__0");
+ put(grammarAccess.getXIfExpressionAccess().getGroup_6(), "rule__XIfExpression__Group_6__0");
+ put(grammarAccess.getXSwitchExpressionAccess().getGroup(), "rule__XSwitchExpression__Group__0");
+ put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0(), "rule__XSwitchExpression__Group_2_0__0");
+ put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0(), "rule__XSwitchExpression__Group_2_0_0__0");
+ put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0(), "rule__XSwitchExpression__Group_2_0_0_0__0");
+ put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1(), "rule__XSwitchExpression__Group_2_1__0");
+ put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0(), "rule__XSwitchExpression__Group_2_1_0__0");
+ put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0(), "rule__XSwitchExpression__Group_2_1_0_0__0");
+ put(grammarAccess.getXSwitchExpressionAccess().getGroup_5(), "rule__XSwitchExpression__Group_5__0");
+ put(grammarAccess.getXCasePartAccess().getGroup(), "rule__XCasePart__Group__0");
+ put(grammarAccess.getXCasePartAccess().getGroup_2(), "rule__XCasePart__Group_2__0");
+ put(grammarAccess.getXCasePartAccess().getGroup_3_0(), "rule__XCasePart__Group_3_0__0");
+ put(grammarAccess.getXForLoopExpressionAccess().getGroup(), "rule__XForLoopExpression__Group__0");
+ put(grammarAccess.getXForLoopExpressionAccess().getGroup_0(), "rule__XForLoopExpression__Group_0__0");
+ put(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0(), "rule__XForLoopExpression__Group_0_0__0");
+ put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup(), "rule__XBasicForLoopExpression__Group__0");
+ put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3(), "rule__XBasicForLoopExpression__Group_3__0");
+ put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1(), "rule__XBasicForLoopExpression__Group_3_1__0");
+ put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7(), "rule__XBasicForLoopExpression__Group_7__0");
+ put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1(), "rule__XBasicForLoopExpression__Group_7_1__0");
+ put(grammarAccess.getXWhileExpressionAccess().getGroup(), "rule__XWhileExpression__Group__0");
+ put(grammarAccess.getXDoWhileExpressionAccess().getGroup(), "rule__XDoWhileExpression__Group__0");
+ put(grammarAccess.getXBlockExpressionAccess().getGroup(), "rule__XBlockExpression__Group__0");
+ put(grammarAccess.getXBlockExpressionAccess().getGroup_2(), "rule__XBlockExpression__Group_2__0");
+ put(grammarAccess.getXVariableDeclarationAccess().getGroup(), "rule__XVariableDeclaration__Group__0");
+ put(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0(), "rule__XVariableDeclaration__Group_2_0__0");
+ put(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0(), "rule__XVariableDeclaration__Group_2_0_0__0");
+ put(grammarAccess.getXVariableDeclarationAccess().getGroup_3(), "rule__XVariableDeclaration__Group_3__0");
+ put(grammarAccess.getJvmFormalParameterAccess().getGroup(), "rule__JvmFormalParameter__Group__0");
+ put(grammarAccess.getFullJvmFormalParameterAccess().getGroup(), "rule__FullJvmFormalParameter__Group__0");
+ put(grammarAccess.getXFeatureCallAccess().getGroup(), "rule__XFeatureCall__Group__0");
+ put(grammarAccess.getXFeatureCallAccess().getGroup_1(), "rule__XFeatureCall__Group_1__0");
+ put(grammarAccess.getXFeatureCallAccess().getGroup_1_2(), "rule__XFeatureCall__Group_1_2__0");
+ put(grammarAccess.getXFeatureCallAccess().getGroup_3(), "rule__XFeatureCall__Group_3__0");
+ put(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1(), "rule__XFeatureCall__Group_3_1_1__0");
+ put(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1(), "rule__XFeatureCall__Group_3_1_1_1__0");
+ put(grammarAccess.getXConstructorCallAccess().getGroup(), "rule__XConstructorCall__Group__0");
+ put(grammarAccess.getXConstructorCallAccess().getGroup_3(), "rule__XConstructorCall__Group_3__0");
+ put(grammarAccess.getXConstructorCallAccess().getGroup_3_2(), "rule__XConstructorCall__Group_3_2__0");
+ put(grammarAccess.getXConstructorCallAccess().getGroup_4(), "rule__XConstructorCall__Group_4__0");
+ put(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1(), "rule__XConstructorCall__Group_4_1_1__0");
+ put(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1(), "rule__XConstructorCall__Group_4_1_1_1__0");
+ put(grammarAccess.getXBooleanLiteralAccess().getGroup(), "rule__XBooleanLiteral__Group__0");
+ put(grammarAccess.getXNullLiteralAccess().getGroup(), "rule__XNullLiteral__Group__0");
+ put(grammarAccess.getXNumberLiteralAccess().getGroup(), "rule__XNumberLiteral__Group__0");
+ put(grammarAccess.getXStringLiteralAccess().getGroup(), "rule__XStringLiteral__Group__0");
+ put(grammarAccess.getXTypeLiteralAccess().getGroup(), "rule__XTypeLiteral__Group__0");
+ put(grammarAccess.getXThrowExpressionAccess().getGroup(), "rule__XThrowExpression__Group__0");
+ put(grammarAccess.getXReturnExpressionAccess().getGroup(), "rule__XReturnExpression__Group__0");
+ put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup(), "rule__XTryCatchFinallyExpression__Group__0");
+ put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0(), "rule__XTryCatchFinallyExpression__Group_3_0__0");
+ put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1(), "rule__XTryCatchFinallyExpression__Group_3_0_1__0");
+ put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1(), "rule__XTryCatchFinallyExpression__Group_3_1__0");
+ put(grammarAccess.getXSynchronizedExpressionAccess().getGroup(), "rule__XSynchronizedExpression__Group__0");
+ put(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0(), "rule__XSynchronizedExpression__Group_0__0");
+ put(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0(), "rule__XSynchronizedExpression__Group_0_0__0");
+ put(grammarAccess.getXCatchClauseAccess().getGroup(), "rule__XCatchClause__Group__0");
+ put(grammarAccess.getQualifiedNameAccess().getGroup(), "rule__QualifiedName__Group__0");
+ put(grammarAccess.getQualifiedNameAccess().getGroup_1(), "rule__QualifiedName__Group_1__0");
+ put(grammarAccess.getNumberAccess().getGroup_1(), "rule__Number__Group_1__0");
+ put(grammarAccess.getNumberAccess().getGroup_1_1(), "rule__Number__Group_1_1__0");
+ put(grammarAccess.getStaticQualifierAccess().getGroup(), "rule__StaticQualifier__Group__0");
+ put(grammarAccess.getJvmTypeReferenceAccess().getGroup_0(), "rule__JvmTypeReference__Group_0__0");
+ put(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1(), "rule__JvmTypeReference__Group_0_1__0");
+ put(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0(), "rule__JvmTypeReference__Group_0_1_0__0");
+ put(grammarAccess.getArrayBracketsAccess().getGroup(), "rule__ArrayBrackets__Group__0");
+ put(grammarAccess.getXFunctionTypeRefAccess().getGroup(), "rule__XFunctionTypeRef__Group__0");
+ put(grammarAccess.getXFunctionTypeRefAccess().getGroup_0(), "rule__XFunctionTypeRef__Group_0__0");
+ put(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1(), "rule__XFunctionTypeRef__Group_0_1__0");
+ put(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1(), "rule__XFunctionTypeRef__Group_0_1_1__0");
+ put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup(), "rule__JvmParameterizedTypeReference__Group__0");
+ put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1(), "rule__JvmParameterizedTypeReference__Group_1__0");
+ put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2(), "rule__JvmParameterizedTypeReference__Group_1_2__0");
+ put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4(), "rule__JvmParameterizedTypeReference__Group_1_4__0");
+ put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0(), "rule__JvmParameterizedTypeReference__Group_1_4_0__0");
+ put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0(), "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0");
+ put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2(), "rule__JvmParameterizedTypeReference__Group_1_4_2__0");
+ put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2(), "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0");
+ put(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup(), "rule__JvmWildcardTypeReference__Group__0");
+ put(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0(), "rule__JvmWildcardTypeReference__Group_2_0__0");
+ put(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1(), "rule__JvmWildcardTypeReference__Group_2_1__0");
+ put(grammarAccess.getJvmUpperBoundAccess().getGroup(), "rule__JvmUpperBound__Group__0");
+ put(grammarAccess.getJvmUpperBoundAndedAccess().getGroup(), "rule__JvmUpperBoundAnded__Group__0");
+ put(grammarAccess.getJvmLowerBoundAccess().getGroup(), "rule__JvmLowerBound__Group__0");
+ put(grammarAccess.getJvmLowerBoundAndedAccess().getGroup(), "rule__JvmLowerBoundAnded__Group__0");
+ put(grammarAccess.getJvmTypeParameterAccess().getGroup(), "rule__JvmTypeParameter__Group__0");
+ put(grammarAccess.getJvmTypeParameterAccess().getGroup_1(), "rule__JvmTypeParameter__Group_1__0");
+ put(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup(), "rule__QualifiedNameWithWildcard__Group__0");
+ put(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup(), "rule__QualifiedNameInStaticImport__Group__0");
+ put(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_2_0_0(), "rule__XImportDeclaration__StaticAssignment_2_0_0");
+ put(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_2_0_1(), "rule__XImportDeclaration__ExtensionAssignment_2_0_1");
+ put(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_0_2(), "rule__XImportDeclaration__ImportedTypeAssignment_2_0_2");
+ put(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_2_0_3_0(), "rule__XImportDeclaration__WildcardAssignment_2_0_3_0");
+ put(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_2_0_3_1(), "rule__XImportDeclaration__MemberNameAssignment_2_0_3_1");
+ put(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_1(), "rule__XImportDeclaration__ImportedTypeAssignment_2_1");
+ put(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_2_2(), "rule__XImportDeclaration__ImportedNamespaceAssignment_2_2");
+ put(grammarAccess.getXImportDeclarationAccess().getFqnImportAssignment_2_3_0(), "rule__XImportDeclaration__FqnImportAssignment_2_3_0");
+ put(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameAssignment_2_3_1(), "rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1");
+ put(grammarAccess.getXAnnotationAccess().getAnnotationTypeAssignment_2(), "rule__XAnnotation__AnnotationTypeAssignment_2");
+ put(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_0(), "rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0");
+ put(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_1_1(), "rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1");
+ put(grammarAccess.getXAnnotationAccess().getValueAssignment_3_1_1(), "rule__XAnnotation__ValueAssignment_3_1_1");
+ put(grammarAccess.getXAnnotationElementValuePairAccess().getElementAssignment_0_0_0(), "rule__XAnnotationElementValuePair__ElementAssignment_0_0_0");
+ put(grammarAccess.getXAnnotationElementValuePairAccess().getValueAssignment_1(), "rule__XAnnotationElementValuePair__ValueAssignment_1");
+ put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_0(), "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0");
+ put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_1_1(), "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1");
+ put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_1_1_1_1(), "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1");
+ put(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_0(), "rule__XAnnotationElementValue__ElementsAssignment_0_1_0");
+ put(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_1_1(), "rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1");
+ put(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1(), "rule__XAssignment__FeatureAssignment_0_1");
+ put(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3(), "rule__XAssignment__ValueAssignment_0_3");
+ put(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1(), "rule__XAssignment__FeatureAssignment_1_1_0_0_1");
+ put(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1(), "rule__XAssignment__RightOperandAssignment_1_1_1");
+ put(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XOrExpression__FeatureAssignment_1_0_0_1");
+ put(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1(), "rule__XOrExpression__RightOperandAssignment_1_1");
+ put(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XAndExpression__FeatureAssignment_1_0_0_1");
+ put(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1(), "rule__XAndExpression__RightOperandAssignment_1_1");
+ put(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XEqualityExpression__FeatureAssignment_1_0_0_1");
+ put(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1(), "rule__XEqualityExpression__RightOperandAssignment_1_1");
+ put(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1(), "rule__XRelationalExpression__TypeAssignment_1_0_1");
+ put(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1(), "rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1");
+ put(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1(), "rule__XRelationalExpression__RightOperandAssignment_1_1_1");
+ put(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1");
+ put(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1(), "rule__XOtherOperatorExpression__RightOperandAssignment_1_1");
+ put(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XAdditiveExpression__FeatureAssignment_1_0_0_1");
+ put(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1(), "rule__XAdditiveExpression__RightOperandAssignment_1_1");
+ put(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1");
+ put(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1(), "rule__XMultiplicativeExpression__RightOperandAssignment_1_1");
+ put(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1(), "rule__XUnaryOperation__FeatureAssignment_0_1");
+ put(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2(), "rule__XUnaryOperation__OperandAssignment_0_2");
+ put(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1(), "rule__XCastedExpression__TypeAssignment_1_1");
+ put(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1(), "rule__XPostfixOperation__FeatureAssignment_1_0_1");
+ put(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1(), "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1");
+ put(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2(), "rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2");
+ put(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1(), "rule__XMemberFeatureCall__ValueAssignment_1_0_1");
+ put(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1(), "rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1");
+ put(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2(), "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2");
+ put(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1(), "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1");
+ put(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1(), "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1");
+ put(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2(), "rule__XMemberFeatureCall__FeatureAssignment_1_1_2");
+ put(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0(), "rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0");
+ put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0");
+ put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0");
+ put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1");
+ put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4");
+ put(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0(), "rule__XSetLiteral__ElementsAssignment_3_0");
+ put(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1(), "rule__XSetLiteral__ElementsAssignment_3_1_1");
+ put(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0(), "rule__XListLiteral__ElementsAssignment_3_0");
+ put(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1(), "rule__XListLiteral__ElementsAssignment_3_1_1");
+ put(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0(), "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0");
+ put(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1(), "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1");
+ put(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1(), "rule__XClosure__ExplicitSyntaxAssignment_1_0_1");
+ put(grammarAccess.getXClosureAccess().getExpressionAssignment_2(), "rule__XClosure__ExpressionAssignment_2");
+ put(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0(), "rule__XExpressionInClosure__ExpressionsAssignment_1_0");
+ put(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0(), "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0");
+ put(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1(), "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1");
+ put(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2(), "rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2");
+ put(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1(), "rule__XShortClosure__ExpressionAssignment_1");
+ put(grammarAccess.getXIfExpressionAccess().getIfAssignment_3(), "rule__XIfExpression__IfAssignment_3");
+ put(grammarAccess.getXIfExpressionAccess().getThenAssignment_5(), "rule__XIfExpression__ThenAssignment_5");
+ put(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1(), "rule__XIfExpression__ElseAssignment_6_1");
+ put(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1(), "rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1");
+ put(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1(), "rule__XSwitchExpression__SwitchAssignment_2_0_1");
+ put(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0(), "rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0");
+ put(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1(), "rule__XSwitchExpression__SwitchAssignment_2_1_1");
+ put(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4(), "rule__XSwitchExpression__CasesAssignment_4");
+ put(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2(), "rule__XSwitchExpression__DefaultAssignment_5_2");
+ put(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1(), "rule__XCasePart__TypeGuardAssignment_1");
+ put(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1(), "rule__XCasePart__CaseAssignment_2_1");
+ put(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1(), "rule__XCasePart__ThenAssignment_3_0_1");
+ put(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1(), "rule__XCasePart__FallThroughAssignment_3_1");
+ put(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3(), "rule__XForLoopExpression__DeclaredParamAssignment_0_0_3");
+ put(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1(), "rule__XForLoopExpression__ForExpressionAssignment_1");
+ put(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3(), "rule__XForLoopExpression__EachExpressionAssignment_3");
+ put(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0(), "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0");
+ put(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1(), "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1");
+ put(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5(), "rule__XBasicForLoopExpression__ExpressionAssignment_5");
+ put(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0(), "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0");
+ put(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1(), "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1");
+ put(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9(), "rule__XBasicForLoopExpression__EachExpressionAssignment_9");
+ put(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3(), "rule__XWhileExpression__PredicateAssignment_3");
+ put(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5(), "rule__XWhileExpression__BodyAssignment_5");
+ put(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2(), "rule__XDoWhileExpression__BodyAssignment_2");
+ put(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5(), "rule__XDoWhileExpression__PredicateAssignment_5");
+ put(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0(), "rule__XBlockExpression__ExpressionsAssignment_2_0");
+ put(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0(), "rule__XVariableDeclaration__WriteableAssignment_1_0");
+ put(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0(), "rule__XVariableDeclaration__TypeAssignment_2_0_0_0");
+ put(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1(), "rule__XVariableDeclaration__NameAssignment_2_0_0_1");
+ put(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1(), "rule__XVariableDeclaration__NameAssignment_2_1");
+ put(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1(), "rule__XVariableDeclaration__RightAssignment_3_1");
+ put(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0(), "rule__JvmFormalParameter__ParameterTypeAssignment_0");
+ put(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1(), "rule__JvmFormalParameter__NameAssignment_1");
+ put(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0(), "rule__FullJvmFormalParameter__ParameterTypeAssignment_0");
+ put(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1(), "rule__FullJvmFormalParameter__NameAssignment_1");
+ put(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1(), "rule__XFeatureCall__TypeArgumentsAssignment_1_1");
+ put(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1(), "rule__XFeatureCall__TypeArgumentsAssignment_1_2_1");
+ put(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2(), "rule__XFeatureCall__FeatureAssignment_2");
+ put(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0(), "rule__XFeatureCall__ExplicitOperationCallAssignment_3_0");
+ put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0");
+ put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0");
+ put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1");
+ put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_4");
+ put(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2(), "rule__XConstructorCall__ConstructorAssignment_2");
+ put(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1(), "rule__XConstructorCall__TypeArgumentsAssignment_3_1");
+ put(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1(), "rule__XConstructorCall__TypeArgumentsAssignment_3_2_1");
+ put(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0(), "rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0");
+ put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0(), "rule__XConstructorCall__ArgumentsAssignment_4_1_0");
+ put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0(), "rule__XConstructorCall__ArgumentsAssignment_4_1_1_0");
+ put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1(), "rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1");
+ put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5(), "rule__XConstructorCall__ArgumentsAssignment_5");
+ put(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1(), "rule__XBooleanLiteral__IsTrueAssignment_1_1");
+ put(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1(), "rule__XNumberLiteral__ValueAssignment_1");
+ put(grammarAccess.getXStringLiteralAccess().getValueAssignment_1(), "rule__XStringLiteral__ValueAssignment_1");
+ put(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3(), "rule__XTypeLiteral__TypeAssignment_3");
+ put(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4(), "rule__XTypeLiteral__ArrayDimensionsAssignment_4");
+ put(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2(), "rule__XThrowExpression__ExpressionAssignment_2");
+ put(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2(), "rule__XReturnExpression__ExpressionAssignment_2");
+ put(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2(), "rule__XTryCatchFinallyExpression__ExpressionAssignment_2");
+ put(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0(), "rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0");
+ put(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1(), "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1");
+ put(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1(), "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1");
+ put(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1(), "rule__XSynchronizedExpression__ParamAssignment_1");
+ put(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3(), "rule__XSynchronizedExpression__ExpressionAssignment_3");
+ put(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2(), "rule__XCatchClause__DeclaredParamAssignment_2");
+ put(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4(), "rule__XCatchClause__ExpressionAssignment_4");
+ put(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0(), "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0");
+ put(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1(), "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1");
+ put(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2(), "rule__XFunctionTypeRef__ReturnTypeAssignment_2");
+ put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0(), "rule__JvmParameterizedTypeReference__TypeAssignment_0");
+ put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1");
+ put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1");
+ put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1(), "rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1");
+ put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1");
+ put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1");
+ put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0");
+ put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1");
+ put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0");
+ put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1");
+ put(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1(), "rule__JvmUpperBound__TypeReferenceAssignment_1");
+ put(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1(), "rule__JvmUpperBoundAnded__TypeReferenceAssignment_1");
+ put(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1(), "rule__JvmLowerBound__TypeReferenceAssignment_1");
+ put(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1(), "rule__JvmLowerBoundAnded__TypeReferenceAssignment_1");
+ put(grammarAccess.getJvmTypeParameterAccess().getNameAssignment_0(), "rule__JvmTypeParameter__NameAssignment_0");
+ put(grammarAccess.getJvmTypeParameterAccess().getConstraintsAssignment_1_0(), "rule__JvmTypeParameter__ConstraintsAssignment_1_0");
+ put(grammarAccess.getJvmTypeParameterAccess().getConstraintsAssignment_1_1(), "rule__JvmTypeParameter__ConstraintsAssignment_1_1");
+ put(grammarAccess.getXImportSectionAccess().getImportDeclarationsAssignment(), "rule__XImportSection__ImportDeclarationsAssignment");
+ }
+ };
+ }
+ return nameMappings.get(element);
+ }
+
+ @Override
+ protected String[] getInitialHiddenTokens() {
+ return new String[] { "RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT" };
+ }
+
+ public OXtypeGrammarAccess getGrammarAccess() {
+ return this.grammarAccess;
+ }
+
+ public void setGrammarAccess(OXtypeGrammarAccess grammarAccess) {
+ this.grammarAccess = grammarAccess;
+ }
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/PartialOXtypeContentAssistParser.java b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/PartialOXtypeContentAssistParser.java
new file mode 100644
index 0000000..adbfa4f
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/PartialOXtypeContentAssistParser.java
@@ -0,0 +1,34 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr;
+
+import java.util.Collection;
+import java.util.Collections;
+import org.eclipse.xtext.AbstractRule;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.FollowElement;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
+import org.eclipse.xtext.ide.editor.partialEditing.IPartialEditingContentAssistParser;
+import org.eclipse.xtext.util.PolymorphicDispatcher;
+
+public class PartialOXtypeContentAssistParser extends OXtypeParser implements IPartialEditingContentAssistParser {
+
+ private AbstractRule rule;
+
+ @Override
+ public void initializeFor(AbstractRule rule) {
+ this.rule = rule;
+ }
+
+ @Override
+ protected Collection<FollowElement> getFollowElements(AbstractInternalContentAssistParser parser) {
+ if (rule == null || rule.eIsProxy())
+ return Collections.emptyList();
+ String methodName = "entryRule" + rule.getName();
+ PolymorphicDispatcher<Collection<FollowElement>> dispatcher =
+ new PolymorphicDispatcher<Collection<FollowElement>>(methodName, 0, 0, Collections.singletonList(parser));
+ dispatcher.invoke();
+ return parser.getFollowElements();
+ }
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtype.g b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtype.g
new file mode 100644
index 0000000..f84a267
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtype.g
@@ -0,0 +1,18614 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+grammar InternalOXtype;
+
+options {
+ superClass=AbstractInternalContentAssistParser;
+ backtrack=true;
+}
+
+@lexer::header {
+package org.eclipse.osbp.xtext.oxtype.ide.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.ide.editor.contentassist.antlr.internal.Lexer;
+}
+
+@parser::header {
+package org.eclipse.osbp.xtext.oxtype.ide.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.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+
+}
+@parser::members {
+ private OXtypeGrammarAccess grammarAccess;
+
+ public void setGrammarAccess(OXtypeGrammarAccess grammarAccess) {
+ this.grammarAccess = grammarAccess;
+ }
+
+ @Override
+ protected Grammar getGrammar() {
+ return grammarAccess.getGrammar();
+ }
+
+ @Override
+ protected String getValueForTokenName(String tokenName) {
+ return tokenName;
+ }
+}
+
+// Entry rule entryRuleXImportDeclaration
+entryRuleXImportDeclaration
+:
+{ before(grammarAccess.getXImportDeclarationRule()); }
+ ruleXImportDeclaration
+{ after(grammarAccess.getXImportDeclarationRule()); }
+ EOF
+;
+
+// Rule XImportDeclaration
+ruleXImportDeclaration
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getGroup()); }
+ (rule__XImportDeclaration__Group__0)
+ { after(grammarAccess.getXImportDeclarationAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXAnnotation
+entryRuleXAnnotation
+:
+{ before(grammarAccess.getXAnnotationRule()); }
+ ruleXAnnotation
+{ after(grammarAccess.getXAnnotationRule()); }
+ EOF
+;
+
+// Rule XAnnotation
+ruleXAnnotation
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXAnnotationAccess().getGroup()); }
+ (rule__XAnnotation__Group__0)
+ { after(grammarAccess.getXAnnotationAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXAnnotationElementValuePair
+entryRuleXAnnotationElementValuePair
+:
+{ before(grammarAccess.getXAnnotationElementValuePairRule()); }
+ ruleXAnnotationElementValuePair
+{ after(grammarAccess.getXAnnotationElementValuePairRule()); }
+ EOF
+;
+
+// Rule XAnnotationElementValuePair
+ruleXAnnotationElementValuePair
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXAnnotationElementValuePairAccess().getGroup()); }
+ (rule__XAnnotationElementValuePair__Group__0)
+ { after(grammarAccess.getXAnnotationElementValuePairAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXAnnotationElementValueOrCommaList
+entryRuleXAnnotationElementValueOrCommaList
+:
+{ before(grammarAccess.getXAnnotationElementValueOrCommaListRule()); }
+ ruleXAnnotationElementValueOrCommaList
+{ after(grammarAccess.getXAnnotationElementValueOrCommaListRule()); }
+ EOF
+;
+
+// Rule XAnnotationElementValueOrCommaList
+ruleXAnnotationElementValueOrCommaList
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getAlternatives()); }
+ (rule__XAnnotationElementValueOrCommaList__Alternatives)
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXAnnotationElementValue
+entryRuleXAnnotationElementValue
+:
+{ before(grammarAccess.getXAnnotationElementValueRule()); }
+ ruleXAnnotationElementValue
+{ after(grammarAccess.getXAnnotationElementValueRule()); }
+ EOF
+;
+
+// Rule XAnnotationElementValue
+ruleXAnnotationElementValue
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXAnnotationElementValueAccess().getAlternatives()); }
+ (rule__XAnnotationElementValue__Alternatives)
+ { after(grammarAccess.getXAnnotationElementValueAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXAnnotationOrExpression
+entryRuleXAnnotationOrExpression
+:
+{ before(grammarAccess.getXAnnotationOrExpressionRule()); }
+ ruleXAnnotationOrExpression
+{ after(grammarAccess.getXAnnotationOrExpressionRule()); }
+ EOF
+;
+
+// Rule XAnnotationOrExpression
+ruleXAnnotationOrExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXAnnotationOrExpressionAccess().getAlternatives()); }
+ (rule__XAnnotationOrExpression__Alternatives)
+ { after(grammarAccess.getXAnnotationOrExpressionAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXExpression
+entryRuleXExpression
+:
+{ before(grammarAccess.getXExpressionRule()); }
+ ruleXExpression
+{ after(grammarAccess.getXExpressionRule()); }
+ EOF
+;
+
+// Rule XExpression
+ruleXExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); }
+ ruleXAssignment
+ { after(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXAssignment
+entryRuleXAssignment
+:
+{ before(grammarAccess.getXAssignmentRule()); }
+ ruleXAssignment
+{ after(grammarAccess.getXAssignmentRule()); }
+ EOF
+;
+
+// Rule XAssignment
+ruleXAssignment
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXAssignmentAccess().getAlternatives()); }
+ (rule__XAssignment__Alternatives)
+ { after(grammarAccess.getXAssignmentAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpSingleAssign
+entryRuleOpSingleAssign
+:
+{ before(grammarAccess.getOpSingleAssignRule()); }
+ ruleOpSingleAssign
+{ after(grammarAccess.getOpSingleAssignRule()); }
+ EOF
+;
+
+// Rule OpSingleAssign
+ruleOpSingleAssign
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); }
+ '='
+ { after(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpMultiAssign
+entryRuleOpMultiAssign
+:
+{ before(grammarAccess.getOpMultiAssignRule()); }
+ ruleOpMultiAssign
+{ after(grammarAccess.getOpMultiAssignRule()); }
+ EOF
+;
+
+// Rule OpMultiAssign
+ruleOpMultiAssign
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getOpMultiAssignAccess().getAlternatives()); }
+ (rule__OpMultiAssign__Alternatives)
+ { after(grammarAccess.getOpMultiAssignAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXOrExpression
+entryRuleXOrExpression
+:
+{ before(grammarAccess.getXOrExpressionRule()); }
+ ruleXOrExpression
+{ after(grammarAccess.getXOrExpressionRule()); }
+ EOF
+;
+
+// Rule XOrExpression
+ruleXOrExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXOrExpressionAccess().getGroup()); }
+ (rule__XOrExpression__Group__0)
+ { after(grammarAccess.getXOrExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpOr
+entryRuleOpOr
+:
+{ before(grammarAccess.getOpOrRule()); }
+ ruleOpOr
+{ after(grammarAccess.getOpOrRule()); }
+ EOF
+;
+
+// Rule OpOr
+ruleOpOr
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); }
+ '||'
+ { after(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXAndExpression
+entryRuleXAndExpression
+:
+{ before(grammarAccess.getXAndExpressionRule()); }
+ ruleXAndExpression
+{ after(grammarAccess.getXAndExpressionRule()); }
+ EOF
+;
+
+// Rule XAndExpression
+ruleXAndExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXAndExpressionAccess().getGroup()); }
+ (rule__XAndExpression__Group__0)
+ { after(grammarAccess.getXAndExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpAnd
+entryRuleOpAnd
+:
+{ before(grammarAccess.getOpAndRule()); }
+ ruleOpAnd
+{ after(grammarAccess.getOpAndRule()); }
+ EOF
+;
+
+// Rule OpAnd
+ruleOpAnd
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); }
+ '&&'
+ { after(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXEqualityExpression
+entryRuleXEqualityExpression
+:
+{ before(grammarAccess.getXEqualityExpressionRule()); }
+ ruleXEqualityExpression
+{ after(grammarAccess.getXEqualityExpressionRule()); }
+ EOF
+;
+
+// Rule XEqualityExpression
+ruleXEqualityExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXEqualityExpressionAccess().getGroup()); }
+ (rule__XEqualityExpression__Group__0)
+ { after(grammarAccess.getXEqualityExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpEquality
+entryRuleOpEquality
+:
+{ before(grammarAccess.getOpEqualityRule()); }
+ ruleOpEquality
+{ after(grammarAccess.getOpEqualityRule()); }
+ EOF
+;
+
+// Rule OpEquality
+ruleOpEquality
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getOpEqualityAccess().getAlternatives()); }
+ (rule__OpEquality__Alternatives)
+ { after(grammarAccess.getOpEqualityAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXRelationalExpression
+entryRuleXRelationalExpression
+:
+{ before(grammarAccess.getXRelationalExpressionRule()); }
+ ruleXRelationalExpression
+{ after(grammarAccess.getXRelationalExpressionRule()); }
+ EOF
+;
+
+// Rule XRelationalExpression
+ruleXRelationalExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXRelationalExpressionAccess().getGroup()); }
+ (rule__XRelationalExpression__Group__0)
+ { after(grammarAccess.getXRelationalExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpCompare
+entryRuleOpCompare
+:
+{ before(grammarAccess.getOpCompareRule()); }
+ ruleOpCompare
+{ after(grammarAccess.getOpCompareRule()); }
+ EOF
+;
+
+// Rule OpCompare
+ruleOpCompare
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getOpCompareAccess().getAlternatives()); }
+ (rule__OpCompare__Alternatives)
+ { after(grammarAccess.getOpCompareAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXOtherOperatorExpression
+entryRuleXOtherOperatorExpression
+:
+{ before(grammarAccess.getXOtherOperatorExpressionRule()); }
+ ruleXOtherOperatorExpression
+{ after(grammarAccess.getXOtherOperatorExpressionRule()); }
+ EOF
+;
+
+// Rule XOtherOperatorExpression
+ruleXOtherOperatorExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); }
+ (rule__XOtherOperatorExpression__Group__0)
+ { after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpOther
+entryRuleOpOther
+:
+{ before(grammarAccess.getOpOtherRule()); }
+ ruleOpOther
+{ after(grammarAccess.getOpOtherRule()); }
+ EOF
+;
+
+// Rule OpOther
+ruleOpOther
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getOpOtherAccess().getAlternatives()); }
+ (rule__OpOther__Alternatives)
+ { after(grammarAccess.getOpOtherAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXAdditiveExpression
+entryRuleXAdditiveExpression
+:
+{ before(grammarAccess.getXAdditiveExpressionRule()); }
+ ruleXAdditiveExpression
+{ after(grammarAccess.getXAdditiveExpressionRule()); }
+ EOF
+;
+
+// Rule XAdditiveExpression
+ruleXAdditiveExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXAdditiveExpressionAccess().getGroup()); }
+ (rule__XAdditiveExpression__Group__0)
+ { after(grammarAccess.getXAdditiveExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpAdd
+entryRuleOpAdd
+:
+{ before(grammarAccess.getOpAddRule()); }
+ ruleOpAdd
+{ after(grammarAccess.getOpAddRule()); }
+ EOF
+;
+
+// Rule OpAdd
+ruleOpAdd
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getOpAddAccess().getAlternatives()); }
+ (rule__OpAdd__Alternatives)
+ { after(grammarAccess.getOpAddAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXMultiplicativeExpression
+entryRuleXMultiplicativeExpression
+:
+{ before(grammarAccess.getXMultiplicativeExpressionRule()); }
+ ruleXMultiplicativeExpression
+{ after(grammarAccess.getXMultiplicativeExpressionRule()); }
+ EOF
+;
+
+// Rule XMultiplicativeExpression
+ruleXMultiplicativeExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); }
+ (rule__XMultiplicativeExpression__Group__0)
+ { after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpMulti
+entryRuleOpMulti
+:
+{ before(grammarAccess.getOpMultiRule()); }
+ ruleOpMulti
+{ after(grammarAccess.getOpMultiRule()); }
+ EOF
+;
+
+// Rule OpMulti
+ruleOpMulti
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getOpMultiAccess().getAlternatives()); }
+ (rule__OpMulti__Alternatives)
+ { after(grammarAccess.getOpMultiAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXUnaryOperation
+entryRuleXUnaryOperation
+:
+{ before(grammarAccess.getXUnaryOperationRule()); }
+ ruleXUnaryOperation
+{ after(grammarAccess.getXUnaryOperationRule()); }
+ EOF
+;
+
+// Rule XUnaryOperation
+ruleXUnaryOperation
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXUnaryOperationAccess().getAlternatives()); }
+ (rule__XUnaryOperation__Alternatives)
+ { after(grammarAccess.getXUnaryOperationAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpUnary
+entryRuleOpUnary
+:
+{ before(grammarAccess.getOpUnaryRule()); }
+ ruleOpUnary
+{ after(grammarAccess.getOpUnaryRule()); }
+ EOF
+;
+
+// Rule OpUnary
+ruleOpUnary
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getOpUnaryAccess().getAlternatives()); }
+ (rule__OpUnary__Alternatives)
+ { after(grammarAccess.getOpUnaryAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXCastedExpression
+entryRuleXCastedExpression
+:
+{ before(grammarAccess.getXCastedExpressionRule()); }
+ ruleXCastedExpression
+{ after(grammarAccess.getXCastedExpressionRule()); }
+ EOF
+;
+
+// Rule XCastedExpression
+ruleXCastedExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXCastedExpressionAccess().getGroup()); }
+ (rule__XCastedExpression__Group__0)
+ { after(grammarAccess.getXCastedExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXPostfixOperation
+entryRuleXPostfixOperation
+:
+{ before(grammarAccess.getXPostfixOperationRule()); }
+ ruleXPostfixOperation
+{ after(grammarAccess.getXPostfixOperationRule()); }
+ EOF
+;
+
+// Rule XPostfixOperation
+ruleXPostfixOperation
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXPostfixOperationAccess().getGroup()); }
+ (rule__XPostfixOperation__Group__0)
+ { after(grammarAccess.getXPostfixOperationAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpPostfix
+entryRuleOpPostfix
+:
+{ before(grammarAccess.getOpPostfixRule()); }
+ ruleOpPostfix
+{ after(grammarAccess.getOpPostfixRule()); }
+ EOF
+;
+
+// Rule OpPostfix
+ruleOpPostfix
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getOpPostfixAccess().getAlternatives()); }
+ (rule__OpPostfix__Alternatives)
+ { after(grammarAccess.getOpPostfixAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXMemberFeatureCall
+entryRuleXMemberFeatureCall
+:
+{ before(grammarAccess.getXMemberFeatureCallRule()); }
+ ruleXMemberFeatureCall
+{ after(grammarAccess.getXMemberFeatureCallRule()); }
+ EOF
+;
+
+// Rule XMemberFeatureCall
+ruleXMemberFeatureCall
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getGroup()); }
+ (rule__XMemberFeatureCall__Group__0)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXPrimaryExpression
+entryRuleXPrimaryExpression
+:
+{ before(grammarAccess.getXPrimaryExpressionRule()); }
+ ruleXPrimaryExpression
+{ after(grammarAccess.getXPrimaryExpressionRule()); }
+ EOF
+;
+
+// Rule XPrimaryExpression
+ruleXPrimaryExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); }
+ (rule__XPrimaryExpression__Alternatives)
+ { after(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXLiteral
+entryRuleXLiteral
+:
+{ before(grammarAccess.getXLiteralRule()); }
+ ruleXLiteral
+{ after(grammarAccess.getXLiteralRule()); }
+ EOF
+;
+
+// Rule XLiteral
+ruleXLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXLiteralAccess().getAlternatives()); }
+ (rule__XLiteral__Alternatives)
+ { after(grammarAccess.getXLiteralAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXCollectionLiteral
+entryRuleXCollectionLiteral
+:
+{ before(grammarAccess.getXCollectionLiteralRule()); }
+ ruleXCollectionLiteral
+{ after(grammarAccess.getXCollectionLiteralRule()); }
+ EOF
+;
+
+// Rule XCollectionLiteral
+ruleXCollectionLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); }
+ (rule__XCollectionLiteral__Alternatives)
+ { after(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXSetLiteral
+entryRuleXSetLiteral
+:
+{ before(grammarAccess.getXSetLiteralRule()); }
+ ruleXSetLiteral
+{ after(grammarAccess.getXSetLiteralRule()); }
+ EOF
+;
+
+// Rule XSetLiteral
+ruleXSetLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXSetLiteralAccess().getGroup()); }
+ (rule__XSetLiteral__Group__0)
+ { after(grammarAccess.getXSetLiteralAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXListLiteral
+entryRuleXListLiteral
+:
+{ before(grammarAccess.getXListLiteralRule()); }
+ ruleXListLiteral
+{ after(grammarAccess.getXListLiteralRule()); }
+ EOF
+;
+
+// Rule XListLiteral
+ruleXListLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXListLiteralAccess().getGroup()); }
+ (rule__XListLiteral__Group__0)
+ { after(grammarAccess.getXListLiteralAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXClosure
+entryRuleXClosure
+:
+{ before(grammarAccess.getXClosureRule()); }
+ ruleXClosure
+{ after(grammarAccess.getXClosureRule()); }
+ EOF
+;
+
+// Rule XClosure
+ruleXClosure
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXClosureAccess().getGroup()); }
+ (rule__XClosure__Group__0)
+ { after(grammarAccess.getXClosureAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXExpressionInClosure
+entryRuleXExpressionInClosure
+:
+{ before(grammarAccess.getXExpressionInClosureRule()); }
+ ruleXExpressionInClosure
+{ after(grammarAccess.getXExpressionInClosureRule()); }
+ EOF
+;
+
+// Rule XExpressionInClosure
+ruleXExpressionInClosure
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXExpressionInClosureAccess().getGroup()); }
+ (rule__XExpressionInClosure__Group__0)
+ { after(grammarAccess.getXExpressionInClosureAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXShortClosure
+entryRuleXShortClosure
+:
+{ before(grammarAccess.getXShortClosureRule()); }
+ ruleXShortClosure
+{ after(grammarAccess.getXShortClosureRule()); }
+ EOF
+;
+
+// Rule XShortClosure
+ruleXShortClosure
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXShortClosureAccess().getGroup()); }
+ (rule__XShortClosure__Group__0)
+ { after(grammarAccess.getXShortClosureAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXParenthesizedExpression
+entryRuleXParenthesizedExpression
+:
+{ before(grammarAccess.getXParenthesizedExpressionRule()); }
+ ruleXParenthesizedExpression
+{ after(grammarAccess.getXParenthesizedExpressionRule()); }
+ EOF
+;
+
+// Rule XParenthesizedExpression
+ruleXParenthesizedExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); }
+ (rule__XParenthesizedExpression__Group__0)
+ { after(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXIfExpression
+entryRuleXIfExpression
+:
+{ before(grammarAccess.getXIfExpressionRule()); }
+ ruleXIfExpression
+{ after(grammarAccess.getXIfExpressionRule()); }
+ EOF
+;
+
+// Rule XIfExpression
+ruleXIfExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXIfExpressionAccess().getGroup()); }
+ (rule__XIfExpression__Group__0)
+ { after(grammarAccess.getXIfExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXSwitchExpression
+entryRuleXSwitchExpression
+:
+{ before(grammarAccess.getXSwitchExpressionRule()); }
+ ruleXSwitchExpression
+{ after(grammarAccess.getXSwitchExpressionRule()); }
+ EOF
+;
+
+// Rule XSwitchExpression
+ruleXSwitchExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXSwitchExpressionAccess().getGroup()); }
+ (rule__XSwitchExpression__Group__0)
+ { after(grammarAccess.getXSwitchExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXCasePart
+entryRuleXCasePart
+:
+{ before(grammarAccess.getXCasePartRule()); }
+ ruleXCasePart
+{ after(grammarAccess.getXCasePartRule()); }
+ EOF
+;
+
+// Rule XCasePart
+ruleXCasePart
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXCasePartAccess().getGroup()); }
+ (rule__XCasePart__Group__0)
+ { after(grammarAccess.getXCasePartAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXForLoopExpression
+entryRuleXForLoopExpression
+:
+{ before(grammarAccess.getXForLoopExpressionRule()); }
+ ruleXForLoopExpression
+{ after(grammarAccess.getXForLoopExpressionRule()); }
+ EOF
+;
+
+// Rule XForLoopExpression
+ruleXForLoopExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXForLoopExpressionAccess().getGroup()); }
+ (rule__XForLoopExpression__Group__0)
+ { after(grammarAccess.getXForLoopExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXBasicForLoopExpression
+entryRuleXBasicForLoopExpression
+:
+{ before(grammarAccess.getXBasicForLoopExpressionRule()); }
+ ruleXBasicForLoopExpression
+{ after(grammarAccess.getXBasicForLoopExpressionRule()); }
+ EOF
+;
+
+// Rule XBasicForLoopExpression
+ruleXBasicForLoopExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); }
+ (rule__XBasicForLoopExpression__Group__0)
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXWhileExpression
+entryRuleXWhileExpression
+:
+{ before(grammarAccess.getXWhileExpressionRule()); }
+ ruleXWhileExpression
+{ after(grammarAccess.getXWhileExpressionRule()); }
+ EOF
+;
+
+// Rule XWhileExpression
+ruleXWhileExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXWhileExpressionAccess().getGroup()); }
+ (rule__XWhileExpression__Group__0)
+ { after(grammarAccess.getXWhileExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXDoWhileExpression
+entryRuleXDoWhileExpression
+:
+{ before(grammarAccess.getXDoWhileExpressionRule()); }
+ ruleXDoWhileExpression
+{ after(grammarAccess.getXDoWhileExpressionRule()); }
+ EOF
+;
+
+// Rule XDoWhileExpression
+ruleXDoWhileExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXDoWhileExpressionAccess().getGroup()); }
+ (rule__XDoWhileExpression__Group__0)
+ { after(grammarAccess.getXDoWhileExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXBlockExpression
+entryRuleXBlockExpression
+:
+{ before(grammarAccess.getXBlockExpressionRule()); }
+ ruleXBlockExpression
+{ after(grammarAccess.getXBlockExpressionRule()); }
+ EOF
+;
+
+// Rule XBlockExpression
+ruleXBlockExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXBlockExpressionAccess().getGroup()); }
+ (rule__XBlockExpression__Group__0)
+ { after(grammarAccess.getXBlockExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXExpressionOrVarDeclaration
+entryRuleXExpressionOrVarDeclaration
+:
+{ before(grammarAccess.getXExpressionOrVarDeclarationRule()); }
+ ruleXExpressionOrVarDeclaration
+{ after(grammarAccess.getXExpressionOrVarDeclarationRule()); }
+ EOF
+;
+
+// Rule XExpressionOrVarDeclaration
+ruleXExpressionOrVarDeclaration
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); }
+ (rule__XExpressionOrVarDeclaration__Alternatives)
+ { after(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXVariableDeclaration
+entryRuleXVariableDeclaration
+:
+{ before(grammarAccess.getXVariableDeclarationRule()); }
+ ruleXVariableDeclaration
+{ after(grammarAccess.getXVariableDeclarationRule()); }
+ EOF
+;
+
+// Rule XVariableDeclaration
+ruleXVariableDeclaration
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXVariableDeclarationAccess().getGroup()); }
+ (rule__XVariableDeclaration__Group__0)
+ { after(grammarAccess.getXVariableDeclarationAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleJvmFormalParameter
+entryRuleJvmFormalParameter
+:
+{ before(grammarAccess.getJvmFormalParameterRule()); }
+ ruleJvmFormalParameter
+{ after(grammarAccess.getJvmFormalParameterRule()); }
+ EOF
+;
+
+// Rule JvmFormalParameter
+ruleJvmFormalParameter
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getJvmFormalParameterAccess().getGroup()); }
+ (rule__JvmFormalParameter__Group__0)
+ { after(grammarAccess.getJvmFormalParameterAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleFullJvmFormalParameter
+entryRuleFullJvmFormalParameter
+:
+{ before(grammarAccess.getFullJvmFormalParameterRule()); }
+ ruleFullJvmFormalParameter
+{ after(grammarAccess.getFullJvmFormalParameterRule()); }
+ EOF
+;
+
+// Rule FullJvmFormalParameter
+ruleFullJvmFormalParameter
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); }
+ (rule__FullJvmFormalParameter__Group__0)
+ { after(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXFeatureCall
+entryRuleXFeatureCall
+:
+{ before(grammarAccess.getXFeatureCallRule()); }
+ ruleXFeatureCall
+{ after(grammarAccess.getXFeatureCallRule()); }
+ EOF
+;
+
+// Rule XFeatureCall
+ruleXFeatureCall
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXFeatureCallAccess().getGroup()); }
+ (rule__XFeatureCall__Group__0)
+ { after(grammarAccess.getXFeatureCallAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleFeatureCallID
+entryRuleFeatureCallID
+:
+{ before(grammarAccess.getFeatureCallIDRule()); }
+ ruleFeatureCallID
+{ after(grammarAccess.getFeatureCallIDRule()); }
+ EOF
+;
+
+// Rule FeatureCallID
+ruleFeatureCallID
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getFeatureCallIDAccess().getAlternatives()); }
+ (rule__FeatureCallID__Alternatives)
+ { after(grammarAccess.getFeatureCallIDAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleIdOrSuper
+entryRuleIdOrSuper
+:
+{ before(grammarAccess.getIdOrSuperRule()); }
+ ruleIdOrSuper
+{ after(grammarAccess.getIdOrSuperRule()); }
+ EOF
+;
+
+// Rule IdOrSuper
+ruleIdOrSuper
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getIdOrSuperAccess().getAlternatives()); }
+ (rule__IdOrSuper__Alternatives)
+ { after(grammarAccess.getIdOrSuperAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXConstructorCall
+entryRuleXConstructorCall
+:
+{ before(grammarAccess.getXConstructorCallRule()); }
+ ruleXConstructorCall
+{ after(grammarAccess.getXConstructorCallRule()); }
+ EOF
+;
+
+// Rule XConstructorCall
+ruleXConstructorCall
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXConstructorCallAccess().getGroup()); }
+ (rule__XConstructorCall__Group__0)
+ { after(grammarAccess.getXConstructorCallAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXBooleanLiteral
+entryRuleXBooleanLiteral
+:
+{ before(grammarAccess.getXBooleanLiteralRule()); }
+ ruleXBooleanLiteral
+{ after(grammarAccess.getXBooleanLiteralRule()); }
+ EOF
+;
+
+// Rule XBooleanLiteral
+ruleXBooleanLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXBooleanLiteralAccess().getGroup()); }
+ (rule__XBooleanLiteral__Group__0)
+ { after(grammarAccess.getXBooleanLiteralAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXNullLiteral
+entryRuleXNullLiteral
+:
+{ before(grammarAccess.getXNullLiteralRule()); }
+ ruleXNullLiteral
+{ after(grammarAccess.getXNullLiteralRule()); }
+ EOF
+;
+
+// Rule XNullLiteral
+ruleXNullLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXNullLiteralAccess().getGroup()); }
+ (rule__XNullLiteral__Group__0)
+ { after(grammarAccess.getXNullLiteralAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXNumberLiteral
+entryRuleXNumberLiteral
+:
+{ before(grammarAccess.getXNumberLiteralRule()); }
+ ruleXNumberLiteral
+{ after(grammarAccess.getXNumberLiteralRule()); }
+ EOF
+;
+
+// Rule XNumberLiteral
+ruleXNumberLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXNumberLiteralAccess().getGroup()); }
+ (rule__XNumberLiteral__Group__0)
+ { after(grammarAccess.getXNumberLiteralAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXStringLiteral
+entryRuleXStringLiteral
+:
+{ before(grammarAccess.getXStringLiteralRule()); }
+ ruleXStringLiteral
+{ after(grammarAccess.getXStringLiteralRule()); }
+ EOF
+;
+
+// Rule XStringLiteral
+ruleXStringLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXStringLiteralAccess().getGroup()); }
+ (rule__XStringLiteral__Group__0)
+ { after(grammarAccess.getXStringLiteralAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXTypeLiteral
+entryRuleXTypeLiteral
+:
+{ before(grammarAccess.getXTypeLiteralRule()); }
+ ruleXTypeLiteral
+{ after(grammarAccess.getXTypeLiteralRule()); }
+ EOF
+;
+
+// Rule XTypeLiteral
+ruleXTypeLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXTypeLiteralAccess().getGroup()); }
+ (rule__XTypeLiteral__Group__0)
+ { after(grammarAccess.getXTypeLiteralAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXThrowExpression
+entryRuleXThrowExpression
+:
+{ before(grammarAccess.getXThrowExpressionRule()); }
+ ruleXThrowExpression
+{ after(grammarAccess.getXThrowExpressionRule()); }
+ EOF
+;
+
+// Rule XThrowExpression
+ruleXThrowExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXThrowExpressionAccess().getGroup()); }
+ (rule__XThrowExpression__Group__0)
+ { after(grammarAccess.getXThrowExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXReturnExpression
+entryRuleXReturnExpression
+:
+{ before(grammarAccess.getXReturnExpressionRule()); }
+ ruleXReturnExpression
+{ after(grammarAccess.getXReturnExpressionRule()); }
+ EOF
+;
+
+// Rule XReturnExpression
+ruleXReturnExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXReturnExpressionAccess().getGroup()); }
+ (rule__XReturnExpression__Group__0)
+ { after(grammarAccess.getXReturnExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXTryCatchFinallyExpression
+entryRuleXTryCatchFinallyExpression
+:
+{ before(grammarAccess.getXTryCatchFinallyExpressionRule()); }
+ ruleXTryCatchFinallyExpression
+{ after(grammarAccess.getXTryCatchFinallyExpressionRule()); }
+ EOF
+;
+
+// Rule XTryCatchFinallyExpression
+ruleXTryCatchFinallyExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); }
+ (rule__XTryCatchFinallyExpression__Group__0)
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXSynchronizedExpression
+entryRuleXSynchronizedExpression
+:
+{ before(grammarAccess.getXSynchronizedExpressionRule()); }
+ ruleXSynchronizedExpression
+{ after(grammarAccess.getXSynchronizedExpressionRule()); }
+ EOF
+;
+
+// Rule XSynchronizedExpression
+ruleXSynchronizedExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); }
+ (rule__XSynchronizedExpression__Group__0)
+ { after(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXCatchClause
+entryRuleXCatchClause
+:
+{ before(grammarAccess.getXCatchClauseRule()); }
+ ruleXCatchClause
+{ after(grammarAccess.getXCatchClauseRule()); }
+ EOF
+;
+
+// Rule XCatchClause
+ruleXCatchClause
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXCatchClauseAccess().getGroup()); }
+ (rule__XCatchClause__Group__0)
+ { after(grammarAccess.getXCatchClauseAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleQualifiedName
+entryRuleQualifiedName
+:
+{ before(grammarAccess.getQualifiedNameRule()); }
+ ruleQualifiedName
+{ after(grammarAccess.getQualifiedNameRule()); }
+ EOF
+;
+
+// Rule QualifiedName
+ruleQualifiedName
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getQualifiedNameAccess().getGroup()); }
+ (rule__QualifiedName__Group__0)
+ { after(grammarAccess.getQualifiedNameAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleNumber
+entryRuleNumber
+@init {
+ HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+}
+:
+{ before(grammarAccess.getNumberRule()); }
+ ruleNumber
+{ after(grammarAccess.getNumberRule()); }
+ EOF
+;
+finally {
+ myHiddenTokenState.restore();
+}
+
+// Rule Number
+ruleNumber
+ @init {
+ HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getNumberAccess().getAlternatives()); }
+ (rule__Number__Alternatives)
+ { after(grammarAccess.getNumberAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+ myHiddenTokenState.restore();
+}
+
+// Entry rule entryRuleJvmTypeReference
+entryRuleJvmTypeReference
+:
+{ before(grammarAccess.getJvmTypeReferenceRule()); }
+ ruleJvmTypeReference
+{ after(grammarAccess.getJvmTypeReferenceRule()); }
+ EOF
+;
+
+// Rule JvmTypeReference
+ruleJvmTypeReference
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); }
+ (rule__JvmTypeReference__Alternatives)
+ { after(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleArrayBrackets
+entryRuleArrayBrackets
+:
+{ before(grammarAccess.getArrayBracketsRule()); }
+ ruleArrayBrackets
+{ after(grammarAccess.getArrayBracketsRule()); }
+ EOF
+;
+
+// Rule ArrayBrackets
+ruleArrayBrackets
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getArrayBracketsAccess().getGroup()); }
+ (rule__ArrayBrackets__Group__0)
+ { after(grammarAccess.getArrayBracketsAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXFunctionTypeRef
+entryRuleXFunctionTypeRef
+:
+{ before(grammarAccess.getXFunctionTypeRefRule()); }
+ ruleXFunctionTypeRef
+{ after(grammarAccess.getXFunctionTypeRefRule()); }
+ EOF
+;
+
+// Rule XFunctionTypeRef
+ruleXFunctionTypeRef
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getXFunctionTypeRefAccess().getGroup()); }
+ (rule__XFunctionTypeRef__Group__0)
+ { after(grammarAccess.getXFunctionTypeRefAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleJvmParameterizedTypeReference
+entryRuleJvmParameterizedTypeReference
+:
+{ before(grammarAccess.getJvmParameterizedTypeReferenceRule()); }
+ ruleJvmParameterizedTypeReference
+{ after(grammarAccess.getJvmParameterizedTypeReferenceRule()); }
+ EOF
+;
+
+// Rule JvmParameterizedTypeReference
+ruleJvmParameterizedTypeReference
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); }
+ (rule__JvmParameterizedTypeReference__Group__0)
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleJvmArgumentTypeReference
+entryRuleJvmArgumentTypeReference
+:
+{ before(grammarAccess.getJvmArgumentTypeReferenceRule()); }
+ ruleJvmArgumentTypeReference
+{ after(grammarAccess.getJvmArgumentTypeReferenceRule()); }
+ EOF
+;
+
+// Rule JvmArgumentTypeReference
+ruleJvmArgumentTypeReference
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); }
+ (rule__JvmArgumentTypeReference__Alternatives)
+ { after(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleJvmWildcardTypeReference
+entryRuleJvmWildcardTypeReference
+:
+{ before(grammarAccess.getJvmWildcardTypeReferenceRule()); }
+ ruleJvmWildcardTypeReference
+{ after(grammarAccess.getJvmWildcardTypeReferenceRule()); }
+ EOF
+;
+
+// Rule JvmWildcardTypeReference
+ruleJvmWildcardTypeReference
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); }
+ (rule__JvmWildcardTypeReference__Group__0)
+ { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleJvmUpperBound
+entryRuleJvmUpperBound
+:
+{ before(grammarAccess.getJvmUpperBoundRule()); }
+ ruleJvmUpperBound
+{ after(grammarAccess.getJvmUpperBoundRule()); }
+ EOF
+;
+
+// Rule JvmUpperBound
+ruleJvmUpperBound
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getJvmUpperBoundAccess().getGroup()); }
+ (rule__JvmUpperBound__Group__0)
+ { after(grammarAccess.getJvmUpperBoundAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleJvmUpperBoundAnded
+entryRuleJvmUpperBoundAnded
+:
+{ before(grammarAccess.getJvmUpperBoundAndedRule()); }
+ ruleJvmUpperBoundAnded
+{ after(grammarAccess.getJvmUpperBoundAndedRule()); }
+ EOF
+;
+
+// Rule JvmUpperBoundAnded
+ruleJvmUpperBoundAnded
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); }
+ (rule__JvmUpperBoundAnded__Group__0)
+ { after(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleJvmLowerBound
+entryRuleJvmLowerBound
+:
+{ before(grammarAccess.getJvmLowerBoundRule()); }
+ ruleJvmLowerBound
+{ after(grammarAccess.getJvmLowerBoundRule()); }
+ EOF
+;
+
+// Rule JvmLowerBound
+ruleJvmLowerBound
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getJvmLowerBoundAccess().getGroup()); }
+ (rule__JvmLowerBound__Group__0)
+ { after(grammarAccess.getJvmLowerBoundAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleJvmLowerBoundAnded
+entryRuleJvmLowerBoundAnded
+:
+{ before(grammarAccess.getJvmLowerBoundAndedRule()); }
+ ruleJvmLowerBoundAnded
+{ after(grammarAccess.getJvmLowerBoundAndedRule()); }
+ EOF
+;
+
+// Rule JvmLowerBoundAnded
+ruleJvmLowerBoundAnded
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); }
+ (rule__JvmLowerBoundAnded__Group__0)
+ { after(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleQualifiedNameWithWildcard
+entryRuleQualifiedNameWithWildcard
+:
+{ before(grammarAccess.getQualifiedNameWithWildcardRule()); }
+ ruleQualifiedNameWithWildcard
+{ after(grammarAccess.getQualifiedNameWithWildcardRule()); }
+ EOF
+;
+
+// Rule QualifiedNameWithWildcard
+ruleQualifiedNameWithWildcard
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); }
+ (rule__QualifiedNameWithWildcard__Group__0)
+ { after(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleValidID
+entryRuleValidID
+:
+{ before(grammarAccess.getValidIDRule()); }
+ ruleValidID
+{ after(grammarAccess.getValidIDRule()); }
+ EOF
+;
+
+// Rule ValidID
+ruleValidID
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ { before(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); }
+ RULE_ID
+ { after(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleQualifiedNameInStaticImport
+entryRuleQualifiedNameInStaticImport
+:
+{ before(grammarAccess.getQualifiedNameInStaticImportRule()); }
+ ruleQualifiedNameInStaticImport
+{ after(grammarAccess.getQualifiedNameInStaticImportRule()); }
+ EOF
+;
+
+// Rule QualifiedNameInStaticImport
+ruleQualifiedNameInStaticImport
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+ (
+ (
+ { before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
+ (rule__QualifiedNameInStaticImport__Group__0)
+ { after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
+ )
+ (
+ { before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
+ (rule__QualifiedNameInStaticImport__Group__0)*
+ { after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
+ )
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Alternatives_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getGroup_2_0()); }
+ (rule__XImportDeclaration__Group_2_0__0)
+ { after(grammarAccess.getXImportDeclarationAccess().getGroup_2_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_1()); }
+ (rule__XImportDeclaration__ImportedTypeAssignment_2_1)
+ { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_1()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_2_2()); }
+ (rule__XImportDeclaration__ImportedNamespaceAssignment_2_2)
+ { after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_2_2()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getGroup_2_3()); }
+ (rule__XImportDeclaration__Group_2_3__0)
+ { after(grammarAccess.getXImportDeclarationAccess().getGroup_2_3()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Alternatives_2_0_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_2_0_3_0()); }
+ (rule__XImportDeclaration__WildcardAssignment_2_0_3_0)
+ { after(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_2_0_3_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_2_0_3_1()); }
+ (rule__XImportDeclaration__MemberNameAssignment_2_0_3_1)
+ { after(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_2_0_3_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Alternatives_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAnnotationAccess().getGroup_3_1_0()); }
+ (rule__XAnnotation__Group_3_1_0__0)
+ { after(grammarAccess.getXAnnotationAccess().getGroup_3_1_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXAnnotationAccess().getValueAssignment_3_1_1()); }
+ (rule__XAnnotation__ValueAssignment_3_1_1)
+ { after(grammarAccess.getXAnnotationAccess().getValueAssignment_3_1_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0()); }
+ (rule__XAnnotationElementValueOrCommaList__Group_0__0)
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1()); }
+ (rule__XAnnotationElementValueOrCommaList__Group_1__0)
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0()); }
+ (rule__XAnnotationElementValue__Group_0__0)
+ { after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1()); }
+ ruleXAnnotationOrExpression
+ { after(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationOrExpression__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0()); }
+ ruleXAnnotation
+ { after(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1()); }
+ ruleXExpression
+ { after(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAssignmentAccess().getGroup_0()); }
+ (rule__XAssignment__Group_0__0)
+ { after(grammarAccess.getXAssignmentAccess().getGroup_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXAssignmentAccess().getGroup_1()); }
+ (rule__XAssignment__Group_1__0)
+ { after(grammarAccess.getXAssignmentAccess().getGroup_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); }
+ '+='
+ { after(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); }
+ '-='
+ { after(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); }
+ '*='
+ { after(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); }
+ '/='
+ { after(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); }
+ '%='
+ { after(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpMultiAssignAccess().getGroup_5()); }
+ (rule__OpMultiAssign__Group_5__0)
+ { after(grammarAccess.getOpMultiAssignAccess().getGroup_5()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpMultiAssignAccess().getGroup_6()); }
+ (rule__OpMultiAssign__Group_6__0)
+ { after(grammarAccess.getOpMultiAssignAccess().getGroup_6()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpEquality__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); }
+ '=='
+ { after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); }
+ '!='
+ { after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); }
+ '==='
+ { after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); }
+ '!=='
+ { after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); }
+ (rule__XRelationalExpression__Group_1_0__0)
+ { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); }
+ (rule__XRelationalExpression__Group_1_1__0)
+ { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpCompare__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); }
+ '>='
+ { after(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpCompareAccess().getGroup_1()); }
+ (rule__OpCompare__Group_1__0)
+ { after(grammarAccess.getOpCompareAccess().getGroup_1()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); }
+ '>'
+ { after(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); }
+ '<'
+ { after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+ '->'
+ { after(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); }
+ '..<'
+ { after(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpOtherAccess().getGroup_2()); }
+ (rule__OpOther__Group_2__0)
+ { after(grammarAccess.getOpOtherAccess().getGroup_2()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); }
+ '..'
+ { after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); }
+ '=>'
+ { after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpOtherAccess().getGroup_5()); }
+ (rule__OpOther__Group_5__0)
+ { after(grammarAccess.getOpOtherAccess().getGroup_5()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpOtherAccess().getGroup_6()); }
+ (rule__OpOther__Group_6__0)
+ { after(grammarAccess.getOpOtherAccess().getGroup_6()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); }
+ '<>'
+ { after(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); }
+ '?:'
+ { after(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Alternatives_5_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); }
+ (rule__OpOther__Group_5_1_0__0)
+ { after(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); }
+ '>'
+ { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Alternatives_6_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); }
+ (rule__OpOther__Group_6_1_0__0)
+ { after(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); }
+ '<'
+ { after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); }
+ '=>'
+ { after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpAdd__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); }
+ '+'
+ { after(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); }
+ '-'
+ { after(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpMulti__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); }
+ '*'
+ { after(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); }
+ '**'
+ { after(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); }
+ '/'
+ { after(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); }
+ '%'
+ { after(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XUnaryOperation__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXUnaryOperationAccess().getGroup_0()); }
+ (rule__XUnaryOperation__Group_0__0)
+ { after(grammarAccess.getXUnaryOperationAccess().getGroup_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); }
+ ruleXCastedExpression
+ { after(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpUnary__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); }
+ '!'
+ { after(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); }
+ '-'
+ { after(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); }
+ '+'
+ { after(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpPostfix__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); }
+ '++'
+ { after(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); }
+ '--'
+ { after(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); }
+ (rule__XMemberFeatureCall__Group_1_0__0)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); }
+ (rule__XMemberFeatureCall__Group_1_1__0)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Alternatives_1_0_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); }
+ '.'
+ { after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); }
+ (rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Alternatives_1_1_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); }
+ '.'
+ { after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); }
+ (rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); }
+ (rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Alternatives_1_1_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); }
+ (rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); }
+ (rule__XMemberFeatureCall__Group_1_1_3_1_1__0)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XPrimaryExpression__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); }
+ ruleXConstructorCall
+ { after(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); }
+ ruleXBlockExpression
+ { after(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); }
+ ruleXSwitchExpression
+ { after(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); }
+ (ruleXSynchronizedExpression)
+ { after(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); }
+ ruleXFeatureCall
+ { after(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); }
+ ruleXLiteral
+ { after(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); }
+ ruleXIfExpression
+ { after(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); }
+ (ruleXForLoopExpression)
+ { after(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); }
+ ruleXBasicForLoopExpression
+ { after(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); }
+ ruleXWhileExpression
+ { after(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); }
+ ruleXDoWhileExpression
+ { after(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); }
+ ruleXThrowExpression
+ { after(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); }
+ ruleXReturnExpression
+ { after(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); }
+ ruleXTryCatchFinallyExpression
+ { after(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); }
+ ruleXParenthesizedExpression
+ { after(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XLiteral__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); }
+ ruleXCollectionLiteral
+ { after(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); }
+ (ruleXClosure)
+ { after(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); }
+ ruleXBooleanLiteral
+ { after(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); }
+ ruleXNumberLiteral
+ { after(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); }
+ ruleXNullLiteral
+ { after(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); }
+ ruleXStringLiteral
+ { after(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); }
+ ruleXTypeLiteral
+ { after(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCollectionLiteral__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); }
+ ruleXSetLiteral
+ { after(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); }
+ ruleXListLiteral
+ { after(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Alternatives_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); }
+ (rule__XSwitchExpression__Group_2_0__0)
+ { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); }
+ (rule__XSwitchExpression__Group_2_1__0)
+ { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Alternatives_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXCasePartAccess().getGroup_3_0()); }
+ (rule__XCasePart__Group_3_0__0)
+ { after(grammarAccess.getXCasePartAccess().getGroup_3_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); }
+ (rule__XCasePart__FallThroughAssignment_3_1)
+ { after(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XExpressionOrVarDeclaration__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); }
+ ruleXVariableDeclaration
+ { after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); }
+ ruleXExpression
+ { after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); }
+ (rule__XVariableDeclaration__WriteableAssignment_1_0)
+ { after(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); }
+ 'val'
+ { after(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Alternatives_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); }
+ (rule__XVariableDeclaration__Group_2_0__0)
+ { after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); }
+ (rule__XVariableDeclaration__NameAssignment_2_1)
+ { after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Alternatives_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); }
+ (rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0)
+ { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); }
+ (rule__XFeatureCall__Group_3_1_1__0)
+ { after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__FeatureCallID__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); }
+ ruleValidID
+ { after(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); }
+ 'extends'
+ { after(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); }
+ )
+ |
+ (
+ { before(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); }
+ 'static'
+ { after(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); }
+ )
+ |
+ (
+ { before(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); }
+ 'import'
+ { after(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); }
+ )
+ |
+ (
+ { before(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); }
+ 'extension'
+ { after(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IdOrSuper__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); }
+ ruleFeatureCallID
+ { after(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); }
+ 'super'
+ { after(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Alternatives_4_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); }
+ (rule__XConstructorCall__ArgumentsAssignment_4_1_0)
+ { after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); }
+ (rule__XConstructorCall__Group_4_1_1__0)
+ { after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBooleanLiteral__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); }
+ 'false'
+ { after(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); }
+ (rule__XBooleanLiteral__IsTrueAssignment_1_1)
+ { after(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Alternatives_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); }
+ (rule__XTryCatchFinallyExpression__Group_3_0__0)
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); }
+ (rule__XTryCatchFinallyExpression__Group_3_1__0)
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Number__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); }
+ RULE_HEX
+ { after(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getNumberAccess().getGroup_1()); }
+ (rule__Number__Group_1__0)
+ { after(grammarAccess.getNumberAccess().getGroup_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Number__Alternatives_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); }
+ RULE_INT
+ { after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); }
+ RULE_DECIMAL
+ { after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Number__Alternatives_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); }
+ RULE_INT
+ { after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); }
+ RULE_DECIMAL
+ { after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmTypeReference__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); }
+ (rule__JvmTypeReference__Group_0__0)
+ { after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); }
+ ruleXFunctionTypeRef
+ { after(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmArgumentTypeReference__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); }
+ ruleJvmTypeReference
+ { after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); }
+ ruleJvmWildcardTypeReference
+ { after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Alternatives_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); }
+ (rule__JvmWildcardTypeReference__Group_2_0__0)
+ { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); }
+ )
+ |
+ (
+ { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); }
+ (rule__JvmWildcardTypeReference__Group_2_1__0)
+ { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XImportDeclaration__Group__0__Impl
+ rule__XImportDeclaration__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXImportDeclarationAccess().getOXImportDeclarationAction_0()); }
+ ()
+ { after(grammarAccess.getXImportDeclarationAccess().getOXImportDeclarationAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XImportDeclaration__Group__1__Impl
+ rule__XImportDeclaration__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXImportDeclarationAccess().getImportKeyword_1()); }
+ 'import'
+ { after(grammarAccess.getXImportDeclarationAccess().getImportKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XImportDeclaration__Group__2__Impl
+ rule__XImportDeclaration__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXImportDeclarationAccess().getAlternatives_2()); }
+ (rule__XImportDeclaration__Alternatives_2)
+ { after(grammarAccess.getXImportDeclarationAccess().getAlternatives_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XImportDeclaration__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_3()); }
+ (';')?
+ { after(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XImportDeclaration__Group_2_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XImportDeclaration__Group_2_0__0__Impl
+ rule__XImportDeclaration__Group_2_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_2_0_0()); }
+ (rule__XImportDeclaration__StaticAssignment_2_0_0)
+ { after(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_2_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XImportDeclaration__Group_2_0__1__Impl
+ rule__XImportDeclaration__Group_2_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_2_0_1()); }
+ (rule__XImportDeclaration__ExtensionAssignment_2_0_1)?
+ { after(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_2_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XImportDeclaration__Group_2_0__2__Impl
+ rule__XImportDeclaration__Group_2_0__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_0_2()); }
+ (rule__XImportDeclaration__ImportedTypeAssignment_2_0_2)
+ { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_0_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_0__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XImportDeclaration__Group_2_0__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_0__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXImportDeclarationAccess().getAlternatives_2_0_3()); }
+ (rule__XImportDeclaration__Alternatives_2_0_3)
+ { after(grammarAccess.getXImportDeclarationAccess().getAlternatives_2_0_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XImportDeclaration__Group_2_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XImportDeclaration__Group_2_3__0__Impl
+ rule__XImportDeclaration__Group_2_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXImportDeclarationAccess().getFqnImportAssignment_2_3_0()); }
+ (rule__XImportDeclaration__FqnImportAssignment_2_3_0)
+ { after(grammarAccess.getXImportDeclarationAccess().getFqnImportAssignment_2_3_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XImportDeclaration__Group_2_3__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameAssignment_2_3_1()); }
+ (rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1)
+ { after(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameAssignment_2_3_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotation__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotation__Group__0__Impl
+ rule__XAnnotation__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationAccess().getXAnnotationAction_0()); }
+ ()
+ { after(grammarAccess.getXAnnotationAccess().getXAnnotationAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotation__Group__1__Impl
+ rule__XAnnotation__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationAccess().getCommercialAtKeyword_1()); }
+ '@'
+ { after(grammarAccess.getXAnnotationAccess().getCommercialAtKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotation__Group__2__Impl
+ rule__XAnnotation__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationAccess().getAnnotationTypeAssignment_2()); }
+ (rule__XAnnotation__AnnotationTypeAssignment_2)
+ { after(grammarAccess.getXAnnotationAccess().getAnnotationTypeAssignment_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotation__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationAccess().getGroup_3()); }
+ (rule__XAnnotation__Group_3__0)?
+ { after(grammarAccess.getXAnnotationAccess().getGroup_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotation__Group_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotation__Group_3__0__Impl
+ rule__XAnnotation__Group_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationAccess().getLeftParenthesisKeyword_3_0()); }
+ ('(')
+ { after(grammarAccess.getXAnnotationAccess().getLeftParenthesisKeyword_3_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotation__Group_3__1__Impl
+ rule__XAnnotation__Group_3__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationAccess().getAlternatives_3_1()); }
+ (rule__XAnnotation__Alternatives_3_1)?
+ { after(grammarAccess.getXAnnotationAccess().getAlternatives_3_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotation__Group_3__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationAccess().getRightParenthesisKeyword_3_2()); }
+ ')'
+ { after(grammarAccess.getXAnnotationAccess().getRightParenthesisKeyword_3_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotation__Group_3_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotation__Group_3_1_0__0__Impl
+ rule__XAnnotation__Group_3_1_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_0()); }
+ (rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0)
+ { after(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3_1_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotation__Group_3_1_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3_1_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationAccess().getGroup_3_1_0_1()); }
+ (rule__XAnnotation__Group_3_1_0_1__0)*
+ { after(grammarAccess.getXAnnotationAccess().getGroup_3_1_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotation__Group_3_1_0_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotation__Group_3_1_0_1__0__Impl
+ rule__XAnnotation__Group_3_1_0_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3_1_0_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationAccess().getCommaKeyword_3_1_0_1_0()); }
+ ','
+ { after(grammarAccess.getXAnnotationAccess().getCommaKeyword_3_1_0_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3_1_0_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotation__Group_3_1_0_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3_1_0_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_1_1()); }
+ (rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1)
+ { after(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValuePair__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValuePair__Group__0__Impl
+ rule__XAnnotationElementValuePair__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0()); }
+ (rule__XAnnotationElementValuePair__Group_0__0)
+ { after(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValuePair__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValuePairAccess().getValueAssignment_1()); }
+ (rule__XAnnotationElementValuePair__ValueAssignment_1)
+ { after(grammarAccess.getXAnnotationElementValuePairAccess().getValueAssignment_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValuePair__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValuePair__Group_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0_0()); }
+ (rule__XAnnotationElementValuePair__Group_0_0__0)
+ { after(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValuePair__Group_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValuePair__Group_0_0__0__Impl
+ rule__XAnnotationElementValuePair__Group_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__Group_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValuePairAccess().getElementAssignment_0_0_0()); }
+ (rule__XAnnotationElementValuePair__ElementAssignment_0_0_0)
+ { after(grammarAccess.getXAnnotationElementValuePairAccess().getElementAssignment_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__Group_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValuePair__Group_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__Group_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValuePairAccess().getEqualsSignKeyword_0_0_1()); }
+ '='
+ { after(grammarAccess.getXAnnotationElementValuePairAccess().getEqualsSignKeyword_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValueOrCommaList__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl
+ rule__XAnnotationElementValueOrCommaList__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0()); }
+ (rule__XAnnotationElementValueOrCommaList__Group_0_0__0)
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl
+ rule__XAnnotationElementValueOrCommaList__Group_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1()); }
+ (rule__XAnnotationElementValueOrCommaList__Group_0_1__0)?
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getRightSquareBracketKeyword_0_2()); }
+ ']'
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getRightSquareBracketKeyword_0_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValueOrCommaList__Group_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0_0()); }
+ (rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0)
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl
+ rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralAction_0_0_0_0()); }
+ ()
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralAction_0_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl
+ rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getNumberSignKeyword_0_0_0_1()); }
+ '#'
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getNumberSignKeyword_0_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getLeftSquareBracketKeyword_0_0_0_2()); }
+ '['
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getLeftSquareBracketKeyword_0_0_0_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValueOrCommaList__Group_0_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl
+ rule__XAnnotationElementValueOrCommaList__Group_0_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_0()); }
+ (rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0)
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1_1()); }
+ (rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0)*
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl
+ rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_0_1_1_0()); }
+ ','
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_0_1_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_1_1()); }
+ (rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1)
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValueOrCommaList__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl
+ rule__XAnnotationElementValueOrCommaList__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXAnnotationOrExpressionParserRuleCall_1_0()); }
+ ruleXAnnotationOrExpression
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXAnnotationOrExpressionParserRuleCall_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1()); }
+ (rule__XAnnotationElementValueOrCommaList__Group_1_1__0)?
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValueOrCommaList__Group_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl
+ rule__XAnnotationElementValueOrCommaList__Group_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()); }
+ ()
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ (
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1()); }
+ (rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0)
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1()); }
+ )
+ (
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1()); }
+ (rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0)*
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1()); }
+ )
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl
+ rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_1_1_1_0()); }
+ ','
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_1_1_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_1_1_1_1()); }
+ (rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1)
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_1_1_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValue__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValue__Group_0__0__Impl
+ rule__XAnnotationElementValue__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0()); }
+ (rule__XAnnotationElementValue__Group_0_0__0)
+ { after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValue__Group_0__1__Impl
+ rule__XAnnotationElementValue__Group_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1()); }
+ (rule__XAnnotationElementValue__Group_0_1__0)?
+ { after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValue__Group_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueAccess().getRightSquareBracketKeyword_0_2()); }
+ ']'
+ { after(grammarAccess.getXAnnotationElementValueAccess().getRightSquareBracketKeyword_0_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValue__Group_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValue__Group_0_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0_0()); }
+ (rule__XAnnotationElementValue__Group_0_0_0__0)
+ { after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValue__Group_0_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValue__Group_0_0_0__0__Impl
+ rule__XAnnotationElementValue__Group_0_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueAccess().getXListLiteralAction_0_0_0_0()); }
+ ()
+ { after(grammarAccess.getXAnnotationElementValueAccess().getXListLiteralAction_0_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValue__Group_0_0_0__1__Impl
+ rule__XAnnotationElementValue__Group_0_0_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueAccess().getNumberSignKeyword_0_0_0_1()); }
+ '#'
+ { after(grammarAccess.getXAnnotationElementValueAccess().getNumberSignKeyword_0_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_0_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValue__Group_0_0_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_0_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueAccess().getLeftSquareBracketKeyword_0_0_0_2()); }
+ '['
+ { after(grammarAccess.getXAnnotationElementValueAccess().getLeftSquareBracketKeyword_0_0_0_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValue__Group_0_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValue__Group_0_1__0__Impl
+ rule__XAnnotationElementValue__Group_0_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_0()); }
+ (rule__XAnnotationElementValue__ElementsAssignment_0_1_0)
+ { after(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValue__Group_0_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1_1()); }
+ (rule__XAnnotationElementValue__Group_0_1_1__0)*
+ { after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValue__Group_0_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValue__Group_0_1_1__0__Impl
+ rule__XAnnotationElementValue__Group_0_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueAccess().getCommaKeyword_0_1_1_0()); }
+ ','
+ { after(grammarAccess.getXAnnotationElementValueAccess().getCommaKeyword_0_1_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAnnotationElementValue__Group_0_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_1_1()); }
+ (rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1)
+ { after(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAssignment__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAssignment__Group_0__0__Impl
+ rule__XAssignment__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); }
+ ()
+ { after(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAssignment__Group_0__1__Impl
+ rule__XAssignment__Group_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); }
+ (rule__XAssignment__FeatureAssignment_0_1)
+ { after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAssignment__Group_0__2__Impl
+ rule__XAssignment__Group_0__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); }
+ ruleOpSingleAssign
+ { after(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_0__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAssignment__Group_0__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_0__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); }
+ (rule__XAssignment__ValueAssignment_0_3)
+ { after(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAssignment__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAssignment__Group_1__0__Impl
+ rule__XAssignment__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); }
+ ruleXOrExpression
+ { after(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAssignment__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAssignmentAccess().getGroup_1_1()); }
+ (rule__XAssignment__Group_1_1__0)?
+ { after(grammarAccess.getXAssignmentAccess().getGroup_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAssignment__Group_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAssignment__Group_1_1__0__Impl
+ rule__XAssignment__Group_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); }
+ (rule__XAssignment__Group_1_1_0__0)
+ { after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAssignment__Group_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); }
+ (rule__XAssignment__RightOperandAssignment_1_1_1)
+ { after(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAssignment__Group_1_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAssignment__Group_1_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); }
+ (rule__XAssignment__Group_1_1_0_0__0)
+ { after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAssignment__Group_1_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAssignment__Group_1_1_0_0__0__Impl
+ rule__XAssignment__Group_1_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); }
+ ()
+ { after(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAssignment__Group_1_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); }
+ (rule__XAssignment__FeatureAssignment_1_1_0_0_1)
+ { after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__OpMultiAssign__Group_5__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpMultiAssign__Group_5__0__Impl
+ rule__OpMultiAssign__Group_5__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_5__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); }
+ '<'
+ { after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_5__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpMultiAssign__Group_5__1__Impl
+ rule__OpMultiAssign__Group_5__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_5__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); }
+ '<'
+ { after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_5__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpMultiAssign__Group_5__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_5__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); }
+ '='
+ { after(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__OpMultiAssign__Group_6__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpMultiAssign__Group_6__0__Impl
+ rule__OpMultiAssign__Group_6__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_6__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); }
+ '>'
+ { after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_6__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpMultiAssign__Group_6__1__Impl
+ rule__OpMultiAssign__Group_6__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_6__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); }
+ ('>')?
+ { after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_6__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpMultiAssign__Group_6__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_6__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); }
+ '>='
+ { after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XOrExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XOrExpression__Group__0__Impl
+ rule__XOrExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); }
+ ruleXAndExpression
+ { after(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XOrExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXOrExpressionAccess().getGroup_1()); }
+ (rule__XOrExpression__Group_1__0)*
+ { after(grammarAccess.getXOrExpressionAccess().getGroup_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XOrExpression__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XOrExpression__Group_1__0__Impl
+ rule__XOrExpression__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); }
+ (rule__XOrExpression__Group_1_0__0)
+ { after(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XOrExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); }
+ (rule__XOrExpression__RightOperandAssignment_1_1)
+ { after(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XOrExpression__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XOrExpression__Group_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); }
+ (rule__XOrExpression__Group_1_0_0__0)
+ { after(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XOrExpression__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XOrExpression__Group_1_0_0__0__Impl
+ rule__XOrExpression__Group_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+ ()
+ { after(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XOrExpression__Group_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+ (rule__XOrExpression__FeatureAssignment_1_0_0_1)
+ { after(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAndExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAndExpression__Group__0__Impl
+ rule__XAndExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); }
+ ruleXEqualityExpression
+ { after(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAndExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAndExpressionAccess().getGroup_1()); }
+ (rule__XAndExpression__Group_1__0)*
+ { after(grammarAccess.getXAndExpressionAccess().getGroup_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAndExpression__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAndExpression__Group_1__0__Impl
+ rule__XAndExpression__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); }
+ (rule__XAndExpression__Group_1_0__0)
+ { after(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAndExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); }
+ (rule__XAndExpression__RightOperandAssignment_1_1)
+ { after(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAndExpression__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAndExpression__Group_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); }
+ (rule__XAndExpression__Group_1_0_0__0)
+ { after(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAndExpression__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAndExpression__Group_1_0_0__0__Impl
+ rule__XAndExpression__Group_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+ ()
+ { after(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAndExpression__Group_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+ (rule__XAndExpression__FeatureAssignment_1_0_0_1)
+ { after(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XEqualityExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XEqualityExpression__Group__0__Impl
+ rule__XEqualityExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); }
+ ruleXRelationalExpression
+ { after(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XEqualityExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); }
+ (rule__XEqualityExpression__Group_1__0)*
+ { after(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XEqualityExpression__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XEqualityExpression__Group_1__0__Impl
+ rule__XEqualityExpression__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); }
+ (rule__XEqualityExpression__Group_1_0__0)
+ { after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XEqualityExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); }
+ (rule__XEqualityExpression__RightOperandAssignment_1_1)
+ { after(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XEqualityExpression__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XEqualityExpression__Group_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); }
+ (rule__XEqualityExpression__Group_1_0_0__0)
+ { after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XEqualityExpression__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XEqualityExpression__Group_1_0_0__0__Impl
+ rule__XEqualityExpression__Group_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+ ()
+ { after(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XEqualityExpression__Group_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+ (rule__XEqualityExpression__FeatureAssignment_1_0_0_1)
+ { after(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XRelationalExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XRelationalExpression__Group__0__Impl
+ rule__XRelationalExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); }
+ ruleXOtherOperatorExpression
+ { after(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XRelationalExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); }
+ (rule__XRelationalExpression__Alternatives_1)*
+ { after(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XRelationalExpression__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XRelationalExpression__Group_1_0__0__Impl
+ rule__XRelationalExpression__Group_1_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); }
+ (rule__XRelationalExpression__Group_1_0_0__0)
+ { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XRelationalExpression__Group_1_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); }
+ (rule__XRelationalExpression__TypeAssignment_1_0_1)
+ { after(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XRelationalExpression__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XRelationalExpression__Group_1_0_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); }
+ (rule__XRelationalExpression__Group_1_0_0_0__0)
+ { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XRelationalExpression__Group_1_0_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XRelationalExpression__Group_1_0_0_0__0__Impl
+ rule__XRelationalExpression__Group_1_0_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_0_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); }
+ ()
+ { after(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_0_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XRelationalExpression__Group_1_0_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_0_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); }
+ 'instanceof'
+ { after(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XRelationalExpression__Group_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XRelationalExpression__Group_1_1__0__Impl
+ rule__XRelationalExpression__Group_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); }
+ (rule__XRelationalExpression__Group_1_1_0__0)
+ { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XRelationalExpression__Group_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); }
+ (rule__XRelationalExpression__RightOperandAssignment_1_1_1)
+ { after(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XRelationalExpression__Group_1_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XRelationalExpression__Group_1_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); }
+ (rule__XRelationalExpression__Group_1_1_0_0__0)
+ { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XRelationalExpression__Group_1_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XRelationalExpression__Group_1_1_0_0__0__Impl
+ rule__XRelationalExpression__Group_1_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); }
+ ()
+ { after(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XRelationalExpression__Group_1_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); }
+ (rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1)
+ { after(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__OpCompare__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpCompare__Group_1__0__Impl
+ rule__OpCompare__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpCompare__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); }
+ '<'
+ { after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpCompare__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpCompare__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpCompare__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); }
+ '='
+ { after(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XOtherOperatorExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XOtherOperatorExpression__Group__0__Impl
+ rule__XOtherOperatorExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); }
+ ruleXAdditiveExpression
+ { after(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XOtherOperatorExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); }
+ (rule__XOtherOperatorExpression__Group_1__0)*
+ { after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XOtherOperatorExpression__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XOtherOperatorExpression__Group_1__0__Impl
+ rule__XOtherOperatorExpression__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); }
+ (rule__XOtherOperatorExpression__Group_1_0__0)
+ { after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XOtherOperatorExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); }
+ (rule__XOtherOperatorExpression__RightOperandAssignment_1_1)
+ { after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XOtherOperatorExpression__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XOtherOperatorExpression__Group_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); }
+ (rule__XOtherOperatorExpression__Group_1_0_0__0)
+ { after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XOtherOperatorExpression__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XOtherOperatorExpression__Group_1_0_0__0__Impl
+ rule__XOtherOperatorExpression__Group_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+ ()
+ { after(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XOtherOperatorExpression__Group_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+ (rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1)
+ { after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__OpOther__Group_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpOther__Group_2__0__Impl
+ rule__OpOther__Group_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); }
+ '>'
+ { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpOther__Group_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); }
+ '..'
+ { after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__OpOther__Group_5__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpOther__Group_5__0__Impl
+ rule__OpOther__Group_5__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_5__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); }
+ '>'
+ { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_5__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpOther__Group_5__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_5__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); }
+ (rule__OpOther__Alternatives_5_1)
+ { after(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__OpOther__Group_5_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpOther__Group_5_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_5_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); }
+ (rule__OpOther__Group_5_1_0_0__0)
+ { after(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__OpOther__Group_5_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpOther__Group_5_1_0_0__0__Impl
+ rule__OpOther__Group_5_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_5_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); }
+ '>'
+ { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_5_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpOther__Group_5_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_5_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); }
+ '>'
+ { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__OpOther__Group_6__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpOther__Group_6__0__Impl
+ rule__OpOther__Group_6__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_6__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); }
+ '<'
+ { after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_6__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpOther__Group_6__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_6__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); }
+ (rule__OpOther__Alternatives_6_1)
+ { after(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__OpOther__Group_6_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpOther__Group_6_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_6_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); }
+ (rule__OpOther__Group_6_1_0_0__0)
+ { after(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__OpOther__Group_6_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpOther__Group_6_1_0_0__0__Impl
+ rule__OpOther__Group_6_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_6_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); }
+ '<'
+ { after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_6_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__OpOther__Group_6_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_6_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); }
+ '<'
+ { after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAdditiveExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAdditiveExpression__Group__0__Impl
+ rule__XAdditiveExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); }
+ ruleXMultiplicativeExpression
+ { after(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAdditiveExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); }
+ (rule__XAdditiveExpression__Group_1__0)*
+ { after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAdditiveExpression__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAdditiveExpression__Group_1__0__Impl
+ rule__XAdditiveExpression__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); }
+ (rule__XAdditiveExpression__Group_1_0__0)
+ { after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAdditiveExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); }
+ (rule__XAdditiveExpression__RightOperandAssignment_1_1)
+ { after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAdditiveExpression__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAdditiveExpression__Group_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); }
+ (rule__XAdditiveExpression__Group_1_0_0__0)
+ { after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XAdditiveExpression__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAdditiveExpression__Group_1_0_0__0__Impl
+ rule__XAdditiveExpression__Group_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+ ()
+ { after(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XAdditiveExpression__Group_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+ (rule__XAdditiveExpression__FeatureAssignment_1_0_0_1)
+ { after(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XMultiplicativeExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMultiplicativeExpression__Group__0__Impl
+ rule__XMultiplicativeExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); }
+ ruleXUnaryOperation
+ { after(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMultiplicativeExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); }
+ (rule__XMultiplicativeExpression__Group_1__0)*
+ { after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XMultiplicativeExpression__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMultiplicativeExpression__Group_1__0__Impl
+ rule__XMultiplicativeExpression__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); }
+ (rule__XMultiplicativeExpression__Group_1_0__0)
+ { after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMultiplicativeExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); }
+ (rule__XMultiplicativeExpression__RightOperandAssignment_1_1)
+ { after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XMultiplicativeExpression__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMultiplicativeExpression__Group_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); }
+ (rule__XMultiplicativeExpression__Group_1_0_0__0)
+ { after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XMultiplicativeExpression__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMultiplicativeExpression__Group_1_0_0__0__Impl
+ rule__XMultiplicativeExpression__Group_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+ ()
+ { after(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMultiplicativeExpression__Group_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+ (rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1)
+ { after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XUnaryOperation__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XUnaryOperation__Group_0__0__Impl
+ rule__XUnaryOperation__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XUnaryOperation__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); }
+ ()
+ { after(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XUnaryOperation__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XUnaryOperation__Group_0__1__Impl
+ rule__XUnaryOperation__Group_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XUnaryOperation__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); }
+ (rule__XUnaryOperation__FeatureAssignment_0_1)
+ { after(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XUnaryOperation__Group_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XUnaryOperation__Group_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XUnaryOperation__Group_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); }
+ (rule__XUnaryOperation__OperandAssignment_0_2)
+ { after(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XCastedExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCastedExpression__Group__0__Impl
+ rule__XCastedExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); }
+ ruleXPostfixOperation
+ { after(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCastedExpression__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCastedExpressionAccess().getGroup_1()); }
+ (rule__XCastedExpression__Group_1__0)*
+ { after(grammarAccess.getXCastedExpressionAccess().getGroup_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XCastedExpression__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCastedExpression__Group_1__0__Impl
+ rule__XCastedExpression__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); }
+ (rule__XCastedExpression__Group_1_0__0)
+ { after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCastedExpression__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); }
+ (rule__XCastedExpression__TypeAssignment_1_1)
+ { after(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XCastedExpression__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCastedExpression__Group_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); }
+ (rule__XCastedExpression__Group_1_0_0__0)
+ { after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XCastedExpression__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCastedExpression__Group_1_0_0__0__Impl
+ rule__XCastedExpression__Group_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); }
+ ()
+ { after(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCastedExpression__Group_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); }
+ 'as'
+ { after(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XPostfixOperation__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XPostfixOperation__Group__0__Impl
+ rule__XPostfixOperation__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XPostfixOperation__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); }
+ ruleXMemberFeatureCall
+ { after(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XPostfixOperation__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XPostfixOperation__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XPostfixOperation__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXPostfixOperationAccess().getGroup_1()); }
+ (rule__XPostfixOperation__Group_1__0)?
+ { after(grammarAccess.getXPostfixOperationAccess().getGroup_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XPostfixOperation__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XPostfixOperation__Group_1__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XPostfixOperation__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); }
+ (rule__XPostfixOperation__Group_1_0__0)
+ { after(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XPostfixOperation__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XPostfixOperation__Group_1_0__0__Impl
+ rule__XPostfixOperation__Group_1_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XPostfixOperation__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); }
+ ()
+ { after(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XPostfixOperation__Group_1_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XPostfixOperation__Group_1_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XPostfixOperation__Group_1_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); }
+ (rule__XPostfixOperation__FeatureAssignment_1_0_1)
+ { after(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group__0__Impl
+ rule__XMemberFeatureCall__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); }
+ ruleXPrimaryExpression
+ { after(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); }
+ (rule__XMemberFeatureCall__Alternatives_1)*
+ { after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_0__0__Impl
+ rule__XMemberFeatureCall__Group_1_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); }
+ (rule__XMemberFeatureCall__Group_1_0_0__0)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); }
+ (rule__XMemberFeatureCall__ValueAssignment_1_0_1)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_0_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); }
+ (rule__XMemberFeatureCall__Group_1_0_0_0__0)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_0_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl
+ rule__XMemberFeatureCall__Group_1_0_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); }
+ ()
+ { after(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl
+ rule__XMemberFeatureCall__Group_1_0_0_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); }
+ (rule__XMemberFeatureCall__Alternatives_1_0_0_0_1)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0_0_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl
+ rule__XMemberFeatureCall__Group_1_0_0_0__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); }
+ (rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0_0_0__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); }
+ ruleOpSingleAssign
+ { after(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1__0__Impl
+ rule__XMemberFeatureCall__Group_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); }
+ (rule__XMemberFeatureCall__Group_1_1_0__0)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1__1__Impl
+ rule__XMemberFeatureCall__Group_1_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); }
+ (rule__XMemberFeatureCall__Group_1_1_1__0)?
+ { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1__2__Impl
+ rule__XMemberFeatureCall__Group_1_1__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); }
+ (rule__XMemberFeatureCall__FeatureAssignment_1_1_2)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1__3__Impl
+ rule__XMemberFeatureCall__Group_1_1__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); }
+ (rule__XMemberFeatureCall__Group_1_1_3__0)?
+ { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); }
+ (rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4)?
+ { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); }
+ (rule__XMemberFeatureCall__Group_1_1_0_0__0)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl
+ rule__XMemberFeatureCall__Group_1_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); }
+ ()
+ { after(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); }
+ (rule__XMemberFeatureCall__Alternatives_1_1_0_0_1)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1_1__0__Impl
+ rule__XMemberFeatureCall__Group_1_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); }
+ '<'
+ { after(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1_1__1__Impl
+ rule__XMemberFeatureCall__Group_1_1_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); }
+ (rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1_1__2__Impl
+ rule__XMemberFeatureCall__Group_1_1_1__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); }
+ (rule__XMemberFeatureCall__Group_1_1_1_2__0)*
+ { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1_1__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); }
+ '>'
+ { after(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_1_1_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl
+ rule__XMemberFeatureCall__Group_1_1_1_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); }
+ ','
+ { after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); }
+ (rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_1_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1_3__0__Impl
+ rule__XMemberFeatureCall__Group_1_1_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); }
+ (rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1_3__1__Impl
+ rule__XMemberFeatureCall__Group_1_1_3__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); }
+ (rule__XMemberFeatureCall__Alternatives_1_1_3_1)?
+ { after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1_3__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); }
+ ')'
+ { after(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_1_3_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl
+ rule__XMemberFeatureCall__Group_1_1_3_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); }
+ (rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); }
+ (rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0)*
+ { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl
+ rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); }
+ ','
+ { after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); }
+ (rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1)
+ { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XSetLiteral__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSetLiteral__Group__0__Impl
+ rule__XSetLiteral__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); }
+ ()
+ { after(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSetLiteral__Group__1__Impl
+ rule__XSetLiteral__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); }
+ '#'
+ { after(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSetLiteral__Group__2__Impl
+ rule__XSetLiteral__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); }
+ '{'
+ { after(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSetLiteral__Group__3__Impl
+ rule__XSetLiteral__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSetLiteralAccess().getGroup_3()); }
+ (rule__XSetLiteral__Group_3__0)?
+ { after(grammarAccess.getXSetLiteralAccess().getGroup_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSetLiteral__Group__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); }
+ '}'
+ { after(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XSetLiteral__Group_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSetLiteral__Group_3__0__Impl
+ rule__XSetLiteral__Group_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); }
+ (rule__XSetLiteral__ElementsAssignment_3_0)
+ { after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSetLiteral__Group_3__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); }
+ (rule__XSetLiteral__Group_3_1__0)*
+ { after(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XSetLiteral__Group_3_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSetLiteral__Group_3_1__0__Impl
+ rule__XSetLiteral__Group_3_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group_3_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); }
+ ','
+ { after(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group_3_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSetLiteral__Group_3_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group_3_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); }
+ (rule__XSetLiteral__ElementsAssignment_3_1_1)
+ { after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XListLiteral__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XListLiteral__Group__0__Impl
+ rule__XListLiteral__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); }
+ ()
+ { after(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XListLiteral__Group__1__Impl
+ rule__XListLiteral__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); }
+ '#'
+ { after(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XListLiteral__Group__2__Impl
+ rule__XListLiteral__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); }
+ '['
+ { after(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XListLiteral__Group__3__Impl
+ rule__XListLiteral__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXListLiteralAccess().getGroup_3()); }
+ (rule__XListLiteral__Group_3__0)?
+ { after(grammarAccess.getXListLiteralAccess().getGroup_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XListLiteral__Group__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); }
+ ']'
+ { after(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XListLiteral__Group_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XListLiteral__Group_3__0__Impl
+ rule__XListLiteral__Group_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); }
+ (rule__XListLiteral__ElementsAssignment_3_0)
+ { after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XListLiteral__Group_3__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXListLiteralAccess().getGroup_3_1()); }
+ (rule__XListLiteral__Group_3_1__0)*
+ { after(grammarAccess.getXListLiteralAccess().getGroup_3_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XListLiteral__Group_3_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XListLiteral__Group_3_1__0__Impl
+ rule__XListLiteral__Group_3_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group_3_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); }
+ ','
+ { after(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group_3_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XListLiteral__Group_3_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group_3_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); }
+ (rule__XListLiteral__ElementsAssignment_3_1_1)
+ { after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XClosure__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XClosure__Group__0__Impl
+ rule__XClosure__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXClosureAccess().getGroup_0()); }
+ (rule__XClosure__Group_0__0)
+ { after(grammarAccess.getXClosureAccess().getGroup_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XClosure__Group__1__Impl
+ rule__XClosure__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXClosureAccess().getGroup_1()); }
+ (rule__XClosure__Group_1__0)?
+ { after(grammarAccess.getXClosureAccess().getGroup_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XClosure__Group__2__Impl
+ rule__XClosure__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); }
+ (rule__XClosure__ExpressionAssignment_2)
+ { after(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XClosure__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); }
+ ']'
+ { after(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XClosure__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XClosure__Group_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXClosureAccess().getGroup_0_0()); }
+ (rule__XClosure__Group_0_0__0)
+ { after(grammarAccess.getXClosureAccess().getGroup_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XClosure__Group_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XClosure__Group_0_0__0__Impl
+ rule__XClosure__Group_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); }
+ ()
+ { after(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XClosure__Group_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); }
+ '['
+ { after(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XClosure__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XClosure__Group_1__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXClosureAccess().getGroup_1_0()); }
+ (rule__XClosure__Group_1_0__0)
+ { after(grammarAccess.getXClosureAccess().getGroup_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XClosure__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XClosure__Group_1_0__0__Impl
+ rule__XClosure__Group_1_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXClosureAccess().getGroup_1_0_0()); }
+ (rule__XClosure__Group_1_0_0__0)?
+ { after(grammarAccess.getXClosureAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XClosure__Group_1_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); }
+ (rule__XClosure__ExplicitSyntaxAssignment_1_0_1)
+ { after(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XClosure__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XClosure__Group_1_0_0__0__Impl
+ rule__XClosure__Group_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); }
+ (rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0)
+ { after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XClosure__Group_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); }
+ (rule__XClosure__Group_1_0_0_1__0)*
+ { after(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XClosure__Group_1_0_0_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XClosure__Group_1_0_0_1__0__Impl
+ rule__XClosure__Group_1_0_0_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0_0_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); }
+ ','
+ { after(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0_0_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XClosure__Group_1_0_0_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0_0_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); }
+ (rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1)
+ { after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XExpressionInClosure__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XExpressionInClosure__Group__0__Impl
+ rule__XExpressionInClosure__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XExpressionInClosure__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); }
+ ()
+ { after(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XExpressionInClosure__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XExpressionInClosure__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XExpressionInClosure__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); }
+ (rule__XExpressionInClosure__Group_1__0)*
+ { after(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XExpressionInClosure__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XExpressionInClosure__Group_1__0__Impl
+ rule__XExpressionInClosure__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XExpressionInClosure__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); }
+ (rule__XExpressionInClosure__ExpressionsAssignment_1_0)
+ { after(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XExpressionInClosure__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XExpressionInClosure__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XExpressionInClosure__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); }
+ (';')?
+ { after(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XShortClosure__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XShortClosure__Group__0__Impl
+ rule__XShortClosure__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXShortClosureAccess().getGroup_0()); }
+ (rule__XShortClosure__Group_0__0)
+ { after(grammarAccess.getXShortClosureAccess().getGroup_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XShortClosure__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); }
+ (rule__XShortClosure__ExpressionAssignment_1)
+ { after(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XShortClosure__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XShortClosure__Group_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXShortClosureAccess().getGroup_0_0()); }
+ (rule__XShortClosure__Group_0_0__0)
+ { after(grammarAccess.getXShortClosureAccess().getGroup_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XShortClosure__Group_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XShortClosure__Group_0_0__0__Impl
+ rule__XShortClosure__Group_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); }
+ ()
+ { after(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XShortClosure__Group_0_0__1__Impl
+ rule__XShortClosure__Group_0_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); }
+ (rule__XShortClosure__Group_0_0_1__0)?
+ { after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XShortClosure__Group_0_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); }
+ (rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2)
+ { after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XShortClosure__Group_0_0_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XShortClosure__Group_0_0_1__0__Impl
+ rule__XShortClosure__Group_0_0_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); }
+ (rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0)
+ { after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XShortClosure__Group_0_0_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); }
+ (rule__XShortClosure__Group_0_0_1_1__0)*
+ { after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XShortClosure__Group_0_0_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XShortClosure__Group_0_0_1_1__0__Impl
+ rule__XShortClosure__Group_0_0_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); }
+ ','
+ { after(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XShortClosure__Group_0_0_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); }
+ (rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1)
+ { after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XParenthesizedExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XParenthesizedExpression__Group__0__Impl
+ rule__XParenthesizedExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XParenthesizedExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); }
+ '('
+ { after(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XParenthesizedExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XParenthesizedExpression__Group__1__Impl
+ rule__XParenthesizedExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XParenthesizedExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); }
+ ruleXExpression
+ { after(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XParenthesizedExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XParenthesizedExpression__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XParenthesizedExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); }
+ ')'
+ { after(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XIfExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XIfExpression__Group__0__Impl
+ rule__XIfExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); }
+ ()
+ { after(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XIfExpression__Group__1__Impl
+ rule__XIfExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); }
+ 'if'
+ { after(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XIfExpression__Group__2__Impl
+ rule__XIfExpression__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); }
+ '('
+ { after(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XIfExpression__Group__3__Impl
+ rule__XIfExpression__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); }
+ (rule__XIfExpression__IfAssignment_3)
+ { after(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XIfExpression__Group__4__Impl
+ rule__XIfExpression__Group__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); }
+ ')'
+ { after(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XIfExpression__Group__5__Impl
+ rule__XIfExpression__Group__6
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); }
+ (rule__XIfExpression__ThenAssignment_5)
+ { after(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XIfExpression__Group__6__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__6__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXIfExpressionAccess().getGroup_6()); }
+ (rule__XIfExpression__Group_6__0)?
+ { after(grammarAccess.getXIfExpressionAccess().getGroup_6()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XIfExpression__Group_6__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XIfExpression__Group_6__0__Impl
+ rule__XIfExpression__Group_6__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group_6__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); }
+ ('else')
+ { after(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group_6__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XIfExpression__Group_6__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group_6__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); }
+ (rule__XIfExpression__ElseAssignment_6_1)
+ { after(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XSwitchExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group__0__Impl
+ rule__XSwitchExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); }
+ ()
+ { after(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group__1__Impl
+ rule__XSwitchExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); }
+ 'switch'
+ { after(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group__2__Impl
+ rule__XSwitchExpression__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); }
+ (rule__XSwitchExpression__Alternatives_2)
+ { after(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group__3__Impl
+ rule__XSwitchExpression__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); }
+ '{'
+ { after(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group__4__Impl
+ rule__XSwitchExpression__Group__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); }
+ (rule__XSwitchExpression__CasesAssignment_4)*
+ { after(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group__5__Impl
+ rule__XSwitchExpression__Group__6
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); }
+ (rule__XSwitchExpression__Group_5__0)?
+ { after(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group__6__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__6__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); }
+ '}'
+ { after(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XSwitchExpression__Group_2_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group_2_0__0__Impl
+ rule__XSwitchExpression__Group_2_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); }
+ (rule__XSwitchExpression__Group_2_0_0__0)
+ { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group_2_0__1__Impl
+ rule__XSwitchExpression__Group_2_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); }
+ (rule__XSwitchExpression__SwitchAssignment_2_0_1)
+ { after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group_2_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); }
+ ')'
+ { after(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XSwitchExpression__Group_2_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group_2_0_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); }
+ (rule__XSwitchExpression__Group_2_0_0_0__0)
+ { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XSwitchExpression__Group_2_0_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group_2_0_0_0__0__Impl
+ rule__XSwitchExpression__Group_2_0_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); }
+ '('
+ { after(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group_2_0_0_0__1__Impl
+ rule__XSwitchExpression__Group_2_0_0_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); }
+ (rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1)
+ { after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0_0_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group_2_0_0_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0_0_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); }
+ ':'
+ { after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XSwitchExpression__Group_2_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group_2_1__0__Impl
+ rule__XSwitchExpression__Group_2_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); }
+ (rule__XSwitchExpression__Group_2_1_0__0)?
+ { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group_2_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); }
+ (rule__XSwitchExpression__SwitchAssignment_2_1_1)
+ { after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XSwitchExpression__Group_2_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group_2_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); }
+ (rule__XSwitchExpression__Group_2_1_0_0__0)
+ { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XSwitchExpression__Group_2_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group_2_1_0_0__0__Impl
+ rule__XSwitchExpression__Group_2_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); }
+ (rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0)
+ { after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group_2_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); }
+ ':'
+ { after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XSwitchExpression__Group_5__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group_5__0__Impl
+ rule__XSwitchExpression__Group_5__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_5__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); }
+ 'default'
+ { after(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_5__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group_5__1__Impl
+ rule__XSwitchExpression__Group_5__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_5__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); }
+ ':'
+ { after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_5__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSwitchExpression__Group_5__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_5__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); }
+ (rule__XSwitchExpression__DefaultAssignment_5_2)
+ { after(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XCasePart__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCasePart__Group__0__Impl
+ rule__XCasePart__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); }
+ ()
+ { after(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCasePart__Group__1__Impl
+ rule__XCasePart__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); }
+ (rule__XCasePart__TypeGuardAssignment_1)?
+ { after(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCasePart__Group__2__Impl
+ rule__XCasePart__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCasePartAccess().getGroup_2()); }
+ (rule__XCasePart__Group_2__0)?
+ { after(grammarAccess.getXCasePartAccess().getGroup_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCasePart__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCasePartAccess().getAlternatives_3()); }
+ (rule__XCasePart__Alternatives_3)
+ { after(grammarAccess.getXCasePartAccess().getAlternatives_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XCasePart__Group_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCasePart__Group_2__0__Impl
+ rule__XCasePart__Group_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); }
+ 'case'
+ { after(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCasePart__Group_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); }
+ (rule__XCasePart__CaseAssignment_2_1)
+ { after(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XCasePart__Group_3_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCasePart__Group_3_0__0__Impl
+ rule__XCasePart__Group_3_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group_3_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); }
+ ':'
+ { after(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group_3_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCasePart__Group_3_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group_3_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); }
+ (rule__XCasePart__ThenAssignment_3_0_1)
+ { after(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XForLoopExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XForLoopExpression__Group__0__Impl
+ rule__XForLoopExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); }
+ (rule__XForLoopExpression__Group_0__0)
+ { after(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XForLoopExpression__Group__1__Impl
+ rule__XForLoopExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); }
+ (rule__XForLoopExpression__ForExpressionAssignment_1)
+ { after(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XForLoopExpression__Group__2__Impl
+ rule__XForLoopExpression__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); }
+ ')'
+ { after(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XForLoopExpression__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); }
+ (rule__XForLoopExpression__EachExpressionAssignment_3)
+ { after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XForLoopExpression__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XForLoopExpression__Group_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); }
+ (rule__XForLoopExpression__Group_0_0__0)
+ { after(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XForLoopExpression__Group_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XForLoopExpression__Group_0_0__0__Impl
+ rule__XForLoopExpression__Group_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); }
+ ()
+ { after(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XForLoopExpression__Group_0_0__1__Impl
+ rule__XForLoopExpression__Group_0_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); }
+ 'for'
+ { after(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XForLoopExpression__Group_0_0__2__Impl
+ rule__XForLoopExpression__Group_0_0__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); }
+ '('
+ { after(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XForLoopExpression__Group_0_0__3__Impl
+ rule__XForLoopExpression__Group_0_0__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); }
+ (rule__XForLoopExpression__DeclaredParamAssignment_0_0_3)
+ { after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XForLoopExpression__Group_0_0__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); }
+ ':'
+ { after(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XBasicForLoopExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group__0__Impl
+ rule__XBasicForLoopExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); }
+ ()
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group__1__Impl
+ rule__XBasicForLoopExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); }
+ 'for'
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group__2__Impl
+ rule__XBasicForLoopExpression__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); }
+ '('
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group__3__Impl
+ rule__XBasicForLoopExpression__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); }
+ (rule__XBasicForLoopExpression__Group_3__0)?
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group__4__Impl
+ rule__XBasicForLoopExpression__Group__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); }
+ ';'
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group__5__Impl
+ rule__XBasicForLoopExpression__Group__6
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); }
+ (rule__XBasicForLoopExpression__ExpressionAssignment_5)?
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group__6__Impl
+ rule__XBasicForLoopExpression__Group__7
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__6__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); }
+ ';'
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__7
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group__7__Impl
+ rule__XBasicForLoopExpression__Group__8
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__7__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); }
+ (rule__XBasicForLoopExpression__Group_7__0)?
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__8
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group__8__Impl
+ rule__XBasicForLoopExpression__Group__9
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__8__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); }
+ ')'
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__9
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group__9__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__9__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); }
+ (rule__XBasicForLoopExpression__EachExpressionAssignment_9)
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XBasicForLoopExpression__Group_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group_3__0__Impl
+ rule__XBasicForLoopExpression__Group_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); }
+ (rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0)
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group_3__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); }
+ (rule__XBasicForLoopExpression__Group_3_1__0)*
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XBasicForLoopExpression__Group_3_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group_3_1__0__Impl
+ rule__XBasicForLoopExpression__Group_3_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_3_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); }
+ ','
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_3_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group_3_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_3_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); }
+ (rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1)
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XBasicForLoopExpression__Group_7__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group_7__0__Impl
+ rule__XBasicForLoopExpression__Group_7__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_7__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); }
+ (rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0)
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_7__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group_7__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_7__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); }
+ (rule__XBasicForLoopExpression__Group_7_1__0)*
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XBasicForLoopExpression__Group_7_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group_7_1__0__Impl
+ rule__XBasicForLoopExpression__Group_7_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_7_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); }
+ ','
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_7_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBasicForLoopExpression__Group_7_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_7_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); }
+ (rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1)
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XWhileExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XWhileExpression__Group__0__Impl
+ rule__XWhileExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); }
+ ()
+ { after(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XWhileExpression__Group__1__Impl
+ rule__XWhileExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); }
+ 'while'
+ { after(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XWhileExpression__Group__2__Impl
+ rule__XWhileExpression__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); }
+ '('
+ { after(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XWhileExpression__Group__3__Impl
+ rule__XWhileExpression__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); }
+ (rule__XWhileExpression__PredicateAssignment_3)
+ { after(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XWhileExpression__Group__4__Impl
+ rule__XWhileExpression__Group__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); }
+ ')'
+ { after(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XWhileExpression__Group__5__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); }
+ (rule__XWhileExpression__BodyAssignment_5)
+ { after(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XDoWhileExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XDoWhileExpression__Group__0__Impl
+ rule__XDoWhileExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); }
+ ()
+ { after(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XDoWhileExpression__Group__1__Impl
+ rule__XDoWhileExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); }
+ 'do'
+ { after(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XDoWhileExpression__Group__2__Impl
+ rule__XDoWhileExpression__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); }
+ (rule__XDoWhileExpression__BodyAssignment_2)
+ { after(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XDoWhileExpression__Group__3__Impl
+ rule__XDoWhileExpression__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); }
+ 'while'
+ { after(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XDoWhileExpression__Group__4__Impl
+ rule__XDoWhileExpression__Group__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); }
+ '('
+ { after(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XDoWhileExpression__Group__5__Impl
+ rule__XDoWhileExpression__Group__6
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); }
+ (rule__XDoWhileExpression__PredicateAssignment_5)
+ { after(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XDoWhileExpression__Group__6__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__6__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); }
+ ')'
+ { after(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XBlockExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBlockExpression__Group__0__Impl
+ rule__XBlockExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); }
+ ()
+ { after(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBlockExpression__Group__1__Impl
+ rule__XBlockExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); }
+ '{'
+ { after(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBlockExpression__Group__2__Impl
+ rule__XBlockExpression__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBlockExpressionAccess().getGroup_2()); }
+ (rule__XBlockExpression__Group_2__0)*
+ { after(grammarAccess.getXBlockExpressionAccess().getGroup_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBlockExpression__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); }
+ '}'
+ { after(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XBlockExpression__Group_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBlockExpression__Group_2__0__Impl
+ rule__XBlockExpression__Group_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); }
+ (rule__XBlockExpression__ExpressionsAssignment_2_0)
+ { after(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBlockExpression__Group_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); }
+ (';')?
+ { after(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XVariableDeclaration__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XVariableDeclaration__Group__0__Impl
+ rule__XVariableDeclaration__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); }
+ ()
+ { after(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XVariableDeclaration__Group__1__Impl
+ rule__XVariableDeclaration__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); }
+ (rule__XVariableDeclaration__Alternatives_1)
+ { after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XVariableDeclaration__Group__2__Impl
+ rule__XVariableDeclaration__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); }
+ (rule__XVariableDeclaration__Alternatives_2)
+ { after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XVariableDeclaration__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); }
+ (rule__XVariableDeclaration__Group_3__0)?
+ { after(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XVariableDeclaration__Group_2_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XVariableDeclaration__Group_2_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group_2_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); }
+ (rule__XVariableDeclaration__Group_2_0_0__0)
+ { after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XVariableDeclaration__Group_2_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XVariableDeclaration__Group_2_0_0__0__Impl
+ rule__XVariableDeclaration__Group_2_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group_2_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); }
+ (rule__XVariableDeclaration__TypeAssignment_2_0_0_0)
+ { after(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group_2_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XVariableDeclaration__Group_2_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group_2_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); }
+ (rule__XVariableDeclaration__NameAssignment_2_0_0_1)
+ { after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XVariableDeclaration__Group_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XVariableDeclaration__Group_3__0__Impl
+ rule__XVariableDeclaration__Group_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); }
+ '='
+ { after(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XVariableDeclaration__Group_3__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); }
+ (rule__XVariableDeclaration__RightAssignment_3_1)
+ { after(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmFormalParameter__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmFormalParameter__Group__0__Impl
+ rule__JvmFormalParameter__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmFormalParameter__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); }
+ (rule__JvmFormalParameter__ParameterTypeAssignment_0)?
+ { after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmFormalParameter__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmFormalParameter__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmFormalParameter__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); }
+ (rule__JvmFormalParameter__NameAssignment_1)
+ { after(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__FullJvmFormalParameter__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__FullJvmFormalParameter__Group__0__Impl
+ rule__FullJvmFormalParameter__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__FullJvmFormalParameter__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); }
+ (rule__FullJvmFormalParameter__ParameterTypeAssignment_0)
+ { after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__FullJvmFormalParameter__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__FullJvmFormalParameter__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__FullJvmFormalParameter__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); }
+ (rule__FullJvmFormalParameter__NameAssignment_1)
+ { after(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XFeatureCall__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group__0__Impl
+ rule__XFeatureCall__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); }
+ ()
+ { after(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group__1__Impl
+ rule__XFeatureCall__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getGroup_1()); }
+ (rule__XFeatureCall__Group_1__0)?
+ { after(grammarAccess.getXFeatureCallAccess().getGroup_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group__2__Impl
+ rule__XFeatureCall__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); }
+ (rule__XFeatureCall__FeatureAssignment_2)
+ { after(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group__3__Impl
+ rule__XFeatureCall__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getGroup_3()); }
+ (rule__XFeatureCall__Group_3__0)?
+ { after(grammarAccess.getXFeatureCallAccess().getGroup_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); }
+ (rule__XFeatureCall__FeatureCallArgumentsAssignment_4)?
+ { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XFeatureCall__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group_1__0__Impl
+ rule__XFeatureCall__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); }
+ '<'
+ { after(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group_1__1__Impl
+ rule__XFeatureCall__Group_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); }
+ (rule__XFeatureCall__TypeArgumentsAssignment_1_1)
+ { after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group_1__2__Impl
+ rule__XFeatureCall__Group_1__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); }
+ (rule__XFeatureCall__Group_1_2__0)*
+ { after(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group_1__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); }
+ '>'
+ { after(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XFeatureCall__Group_1_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group_1_2__0__Impl
+ rule__XFeatureCall__Group_1_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); }
+ ','
+ { after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group_1_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); }
+ (rule__XFeatureCall__TypeArgumentsAssignment_1_2_1)
+ { after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XFeatureCall__Group_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group_3__0__Impl
+ rule__XFeatureCall__Group_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); }
+ (rule__XFeatureCall__ExplicitOperationCallAssignment_3_0)
+ { after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group_3__1__Impl
+ rule__XFeatureCall__Group_3__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); }
+ (rule__XFeatureCall__Alternatives_3_1)?
+ { after(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group_3__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); }
+ ')'
+ { after(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XFeatureCall__Group_3_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group_3_1_1__0__Impl
+ rule__XFeatureCall__Group_3_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); }
+ (rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0)
+ { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group_3_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); }
+ (rule__XFeatureCall__Group_3_1_1_1__0)*
+ { after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XFeatureCall__Group_3_1_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group_3_1_1_1__0__Impl
+ rule__XFeatureCall__Group_3_1_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3_1_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); }
+ ','
+ { after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3_1_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFeatureCall__Group_3_1_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3_1_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); }
+ (rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1)
+ { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XConstructorCall__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group__0__Impl
+ rule__XConstructorCall__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); }
+ ()
+ { after(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group__1__Impl
+ rule__XConstructorCall__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); }
+ 'new'
+ { after(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group__2__Impl
+ rule__XConstructorCall__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); }
+ (rule__XConstructorCall__ConstructorAssignment_2)
+ { after(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group__3__Impl
+ rule__XConstructorCall__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getGroup_3()); }
+ (rule__XConstructorCall__Group_3__0)?
+ { after(grammarAccess.getXConstructorCallAccess().getGroup_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group__4__Impl
+ rule__XConstructorCall__Group__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getGroup_4()); }
+ (rule__XConstructorCall__Group_4__0)?
+ { after(grammarAccess.getXConstructorCallAccess().getGroup_4()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group__5__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); }
+ (rule__XConstructorCall__ArgumentsAssignment_5)?
+ { after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XConstructorCall__Group_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group_3__0__Impl
+ rule__XConstructorCall__Group_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); }
+ ('<')
+ { after(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group_3__1__Impl
+ rule__XConstructorCall__Group_3__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); }
+ (rule__XConstructorCall__TypeArgumentsAssignment_3_1)
+ { after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group_3__2__Impl
+ rule__XConstructorCall__Group_3__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); }
+ (rule__XConstructorCall__Group_3_2__0)*
+ { after(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group_3__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); }
+ '>'
+ { after(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XConstructorCall__Group_3_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group_3_2__0__Impl
+ rule__XConstructorCall__Group_3_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); }
+ ','
+ { after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group_3_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); }
+ (rule__XConstructorCall__TypeArgumentsAssignment_3_2_1)
+ { after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XConstructorCall__Group_4__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group_4__0__Impl
+ rule__XConstructorCall__Group_4__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); }
+ (rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0)
+ { after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group_4__1__Impl
+ rule__XConstructorCall__Group_4__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); }
+ (rule__XConstructorCall__Alternatives_4_1)?
+ { after(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group_4__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); }
+ ')'
+ { after(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XConstructorCall__Group_4_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group_4_1_1__0__Impl
+ rule__XConstructorCall__Group_4_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); }
+ (rule__XConstructorCall__ArgumentsAssignment_4_1_1_0)
+ { after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group_4_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); }
+ (rule__XConstructorCall__Group_4_1_1_1__0)*
+ { after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XConstructorCall__Group_4_1_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group_4_1_1_1__0__Impl
+ rule__XConstructorCall__Group_4_1_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4_1_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); }
+ ','
+ { after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4_1_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XConstructorCall__Group_4_1_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4_1_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); }
+ (rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1)
+ { after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XBooleanLiteral__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBooleanLiteral__Group__0__Impl
+ rule__XBooleanLiteral__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBooleanLiteral__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); }
+ ()
+ { after(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBooleanLiteral__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XBooleanLiteral__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBooleanLiteral__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); }
+ (rule__XBooleanLiteral__Alternatives_1)
+ { after(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XNullLiteral__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XNullLiteral__Group__0__Impl
+ rule__XNullLiteral__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XNullLiteral__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); }
+ ()
+ { after(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XNullLiteral__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XNullLiteral__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XNullLiteral__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); }
+ 'null'
+ { after(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XNumberLiteral__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XNumberLiteral__Group__0__Impl
+ rule__XNumberLiteral__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XNumberLiteral__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); }
+ ()
+ { after(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XNumberLiteral__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XNumberLiteral__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XNumberLiteral__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); }
+ (rule__XNumberLiteral__ValueAssignment_1)
+ { after(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XStringLiteral__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XStringLiteral__Group__0__Impl
+ rule__XStringLiteral__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XStringLiteral__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); }
+ ()
+ { after(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XStringLiteral__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XStringLiteral__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XStringLiteral__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); }
+ (rule__XStringLiteral__ValueAssignment_1)
+ { after(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XTypeLiteral__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XTypeLiteral__Group__0__Impl
+ rule__XTypeLiteral__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); }
+ ()
+ { after(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XTypeLiteral__Group__1__Impl
+ rule__XTypeLiteral__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); }
+ 'typeof'
+ { after(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XTypeLiteral__Group__2__Impl
+ rule__XTypeLiteral__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); }
+ '('
+ { after(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XTypeLiteral__Group__3__Impl
+ rule__XTypeLiteral__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); }
+ (rule__XTypeLiteral__TypeAssignment_3)
+ { after(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XTypeLiteral__Group__4__Impl
+ rule__XTypeLiteral__Group__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); }
+ (rule__XTypeLiteral__ArrayDimensionsAssignment_4)*
+ { after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XTypeLiteral__Group__5__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); }
+ ')'
+ { after(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XThrowExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XThrowExpression__Group__0__Impl
+ rule__XThrowExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XThrowExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); }
+ ()
+ { after(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XThrowExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XThrowExpression__Group__1__Impl
+ rule__XThrowExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XThrowExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); }
+ 'throw'
+ { after(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XThrowExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XThrowExpression__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XThrowExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); }
+ (rule__XThrowExpression__ExpressionAssignment_2)
+ { after(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XReturnExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XReturnExpression__Group__0__Impl
+ rule__XReturnExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XReturnExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); }
+ ()
+ { after(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XReturnExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XReturnExpression__Group__1__Impl
+ rule__XReturnExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XReturnExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); }
+ 'return'
+ { after(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XReturnExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XReturnExpression__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XReturnExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); }
+ (rule__XReturnExpression__ExpressionAssignment_2)?
+ { after(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XTryCatchFinallyExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XTryCatchFinallyExpression__Group__0__Impl
+ rule__XTryCatchFinallyExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); }
+ ()
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XTryCatchFinallyExpression__Group__1__Impl
+ rule__XTryCatchFinallyExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); }
+ 'try'
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XTryCatchFinallyExpression__Group__2__Impl
+ rule__XTryCatchFinallyExpression__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); }
+ (rule__XTryCatchFinallyExpression__ExpressionAssignment_2)
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XTryCatchFinallyExpression__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); }
+ (rule__XTryCatchFinallyExpression__Alternatives_3)
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XTryCatchFinallyExpression__Group_3_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XTryCatchFinallyExpression__Group_3_0__0__Impl
+ rule__XTryCatchFinallyExpression__Group_3_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ (
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); }
+ (rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0)
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); }
+ )
+ (
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); }
+ (rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0)*
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); }
+ )
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XTryCatchFinallyExpression__Group_3_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); }
+ (rule__XTryCatchFinallyExpression__Group_3_0_1__0)?
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XTryCatchFinallyExpression__Group_3_0_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl
+ rule__XTryCatchFinallyExpression__Group_3_0_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); }
+ ('finally')
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_0_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); }
+ (rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1)
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XTryCatchFinallyExpression__Group_3_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XTryCatchFinallyExpression__Group_3_1__0__Impl
+ rule__XTryCatchFinallyExpression__Group_3_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); }
+ 'finally'
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XTryCatchFinallyExpression__Group_3_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); }
+ (rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1)
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XSynchronizedExpression__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSynchronizedExpression__Group__0__Impl
+ rule__XSynchronizedExpression__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); }
+ (rule__XSynchronizedExpression__Group_0__0)
+ { after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSynchronizedExpression__Group__1__Impl
+ rule__XSynchronizedExpression__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); }
+ (rule__XSynchronizedExpression__ParamAssignment_1)
+ { after(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSynchronizedExpression__Group__2__Impl
+ rule__XSynchronizedExpression__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); }
+ ')'
+ { after(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSynchronizedExpression__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); }
+ (rule__XSynchronizedExpression__ExpressionAssignment_3)
+ { after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XSynchronizedExpression__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSynchronizedExpression__Group_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); }
+ (rule__XSynchronizedExpression__Group_0_0__0)
+ { after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XSynchronizedExpression__Group_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSynchronizedExpression__Group_0_0__0__Impl
+ rule__XSynchronizedExpression__Group_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); }
+ ()
+ { after(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSynchronizedExpression__Group_0_0__1__Impl
+ rule__XSynchronizedExpression__Group_0_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); }
+ 'synchronized'
+ { after(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group_0_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XSynchronizedExpression__Group_0_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group_0_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); }
+ '('
+ { after(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XCatchClause__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCatchClause__Group__0__Impl
+ rule__XCatchClause__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); }
+ ('catch')
+ { after(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCatchClause__Group__1__Impl
+ rule__XCatchClause__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); }
+ '('
+ { after(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCatchClause__Group__2__Impl
+ rule__XCatchClause__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); }
+ (rule__XCatchClause__DeclaredParamAssignment_2)
+ { after(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCatchClause__Group__3__Impl
+ rule__XCatchClause__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); }
+ ')'
+ { after(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XCatchClause__Group__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); }
+ (rule__XCatchClause__ExpressionAssignment_4)
+ { after(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedName__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedName__Group__0__Impl
+ rule__QualifiedName__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedName__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); }
+ ruleValidID
+ { after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedName__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedName__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedName__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getQualifiedNameAccess().getGroup_1()); }
+ (rule__QualifiedName__Group_1__0)*
+ { after(grammarAccess.getQualifiedNameAccess().getGroup_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedName__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedName__Group_1__0__Impl
+ rule__QualifiedName__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedName__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); }
+ ('.')
+ { after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedName__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedName__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedName__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); }
+ ruleValidID
+ { after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Number__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Number__Group_1__0__Impl
+ rule__Number__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Number__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getNumberAccess().getAlternatives_1_0()); }
+ (rule__Number__Alternatives_1_0)
+ { after(grammarAccess.getNumberAccess().getAlternatives_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Number__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Number__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Number__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getNumberAccess().getGroup_1_1()); }
+ (rule__Number__Group_1_1__0)?
+ { after(grammarAccess.getNumberAccess().getGroup_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Number__Group_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Number__Group_1_1__0__Impl
+ rule__Number__Group_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Number__Group_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); }
+ '.'
+ { after(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Number__Group_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Number__Group_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Number__Group_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); }
+ (rule__Number__Alternatives_1_1_1)
+ { after(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmTypeReference__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmTypeReference__Group_0__0__Impl
+ rule__JvmTypeReference__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmTypeReference__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); }
+ ruleJvmParameterizedTypeReference
+ { after(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmTypeReference__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmTypeReference__Group_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmTypeReference__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); }
+ (rule__JvmTypeReference__Group_0_1__0)*
+ { after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmTypeReference__Group_0_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmTypeReference__Group_0_1__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmTypeReference__Group_0_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); }
+ (rule__JvmTypeReference__Group_0_1_0__0)
+ { after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmTypeReference__Group_0_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmTypeReference__Group_0_1_0__0__Impl
+ rule__JvmTypeReference__Group_0_1_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmTypeReference__Group_0_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); }
+ ()
+ { after(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmTypeReference__Group_0_1_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmTypeReference__Group_0_1_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmTypeReference__Group_0_1_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); }
+ ruleArrayBrackets
+ { after(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ArrayBrackets__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ArrayBrackets__Group__0__Impl
+ rule__ArrayBrackets__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArrayBrackets__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); }
+ '['
+ { after(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArrayBrackets__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ArrayBrackets__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArrayBrackets__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); }
+ ']'
+ { after(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XFunctionTypeRef__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFunctionTypeRef__Group__0__Impl
+ rule__XFunctionTypeRef__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); }
+ (rule__XFunctionTypeRef__Group_0__0)?
+ { after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFunctionTypeRef__Group__1__Impl
+ rule__XFunctionTypeRef__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); }
+ '=>'
+ { after(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFunctionTypeRef__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); }
+ (rule__XFunctionTypeRef__ReturnTypeAssignment_2)
+ { after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XFunctionTypeRef__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFunctionTypeRef__Group_0__0__Impl
+ rule__XFunctionTypeRef__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); }
+ '('
+ { after(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFunctionTypeRef__Group_0__1__Impl
+ rule__XFunctionTypeRef__Group_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); }
+ (rule__XFunctionTypeRef__Group_0_1__0)?
+ { after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFunctionTypeRef__Group_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); }
+ ')'
+ { after(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XFunctionTypeRef__Group_0_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFunctionTypeRef__Group_0_1__0__Impl
+ rule__XFunctionTypeRef__Group_0_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); }
+ (rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0)
+ { after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFunctionTypeRef__Group_0_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); }
+ (rule__XFunctionTypeRef__Group_0_1_1__0)*
+ { after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XFunctionTypeRef__Group_0_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFunctionTypeRef__Group_0_1_1__0__Impl
+ rule__XFunctionTypeRef__Group_0_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); }
+ ','
+ { after(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__XFunctionTypeRef__Group_0_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); }
+ (rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1)
+ { after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmParameterizedTypeReference__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group__0__Impl
+ rule__JvmParameterizedTypeReference__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); }
+ (rule__JvmParameterizedTypeReference__TypeAssignment_0)
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); }
+ (rule__JvmParameterizedTypeReference__Group_1__0)?
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmParameterizedTypeReference__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1__0__Impl
+ rule__JvmParameterizedTypeReference__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); }
+ ('<')
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1__1__Impl
+ rule__JvmParameterizedTypeReference__Group_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); }
+ (rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1)
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1__2__Impl
+ rule__JvmParameterizedTypeReference__Group_1__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); }
+ (rule__JvmParameterizedTypeReference__Group_1_2__0)*
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1__3__Impl
+ rule__JvmParameterizedTypeReference__Group_1__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); }
+ '>'
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); }
+ (rule__JvmParameterizedTypeReference__Group_1_4__0)*
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmParameterizedTypeReference__Group_1_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1_2__0__Impl
+ rule__JvmParameterizedTypeReference__Group_1_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); }
+ ','
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); }
+ (rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1)
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmParameterizedTypeReference__Group_1_4__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1_4__0__Impl
+ rule__JvmParameterizedTypeReference__Group_1_4__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); }
+ (rule__JvmParameterizedTypeReference__Group_1_4_0__0)
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1_4__1__Impl
+ rule__JvmParameterizedTypeReference__Group_1_4__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); }
+ (rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1)
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1_4__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); }
+ (rule__JvmParameterizedTypeReference__Group_1_4_2__0)?
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmParameterizedTypeReference__Group_1_4_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); }
+ (rule__JvmParameterizedTypeReference__Group_1_4_0_0__0)
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmParameterizedTypeReference__Group_1_4_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl
+ rule__JvmParameterizedTypeReference__Group_1_4_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); }
+ ()
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); }
+ '.'
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmParameterizedTypeReference__Group_1_4_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl
+ rule__JvmParameterizedTypeReference__Group_1_4_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); }
+ ('<')
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl
+ rule__JvmParameterizedTypeReference__Group_1_4_2__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); }
+ (rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1)
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl
+ rule__JvmParameterizedTypeReference__Group_1_4_2__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); }
+ (rule__JvmParameterizedTypeReference__Group_1_4_2_2__0)*
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); }
+ '>'
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmParameterizedTypeReference__Group_1_4_2_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl
+ rule__JvmParameterizedTypeReference__Group_1_4_2_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); }
+ ','
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); }
+ (rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1)
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmWildcardTypeReference__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmWildcardTypeReference__Group__0__Impl
+ rule__JvmWildcardTypeReference__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); }
+ ()
+ { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmWildcardTypeReference__Group__1__Impl
+ rule__JvmWildcardTypeReference__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); }
+ '?'
+ { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmWildcardTypeReference__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); }
+ (rule__JvmWildcardTypeReference__Alternatives_2)?
+ { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmWildcardTypeReference__Group_2_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmWildcardTypeReference__Group_2_0__0__Impl
+ rule__JvmWildcardTypeReference__Group_2_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group_2_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); }
+ (rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0)
+ { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group_2_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmWildcardTypeReference__Group_2_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group_2_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); }
+ (rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1)*
+ { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmWildcardTypeReference__Group_2_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmWildcardTypeReference__Group_2_1__0__Impl
+ rule__JvmWildcardTypeReference__Group_2_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group_2_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); }
+ (rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0)
+ { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group_2_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmWildcardTypeReference__Group_2_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group_2_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); }
+ (rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1)*
+ { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmUpperBound__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmUpperBound__Group__0__Impl
+ rule__JvmUpperBound__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmUpperBound__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); }
+ 'extends'
+ { after(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmUpperBound__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmUpperBound__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmUpperBound__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); }
+ (rule__JvmUpperBound__TypeReferenceAssignment_1)
+ { after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmUpperBoundAnded__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmUpperBoundAnded__Group__0__Impl
+ rule__JvmUpperBoundAnded__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmUpperBoundAnded__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); }
+ '&'
+ { after(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmUpperBoundAnded__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmUpperBoundAnded__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmUpperBoundAnded__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); }
+ (rule__JvmUpperBoundAnded__TypeReferenceAssignment_1)
+ { after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmLowerBound__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmLowerBound__Group__0__Impl
+ rule__JvmLowerBound__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmLowerBound__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); }
+ 'super'
+ { after(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmLowerBound__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmLowerBound__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmLowerBound__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); }
+ (rule__JvmLowerBound__TypeReferenceAssignment_1)
+ { after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JvmLowerBoundAnded__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmLowerBoundAnded__Group__0__Impl
+ rule__JvmLowerBoundAnded__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmLowerBoundAnded__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); }
+ '&'
+ { after(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmLowerBoundAnded__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JvmLowerBoundAnded__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmLowerBoundAnded__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); }
+ (rule__JvmLowerBoundAnded__TypeReferenceAssignment_1)
+ { after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedNameWithWildcard__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedNameWithWildcard__Group__0__Impl
+ rule__QualifiedNameWithWildcard__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithWildcard__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); }
+ ruleQualifiedName
+ { after(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithWildcard__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedNameWithWildcard__Group__1__Impl
+ rule__QualifiedNameWithWildcard__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithWildcard__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); }
+ '.'
+ { after(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithWildcard__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedNameWithWildcard__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithWildcard__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); }
+ '*'
+ { after(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedNameInStaticImport__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedNameInStaticImport__Group__0__Impl
+ rule__QualifiedNameInStaticImport__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameInStaticImport__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); }
+ ruleValidID
+ { after(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameInStaticImport__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__QualifiedNameInStaticImport__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameInStaticImport__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+ { before(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); }
+ '.'
+ { after(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); }
+)
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__XImportDeclaration__StaticAssignment_2_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0()); }
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0()); }
+ 'static'
+ { after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0()); }
+ )
+ { after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__ExtensionAssignment_2_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0()); }
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0()); }
+ 'extension'
+ { after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0()); }
+ )
+ { after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__ImportedTypeAssignment_2_0_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0()); }
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_2_0_2_0_1()); }
+ ruleQualifiedNameInStaticImport
+ { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_2_0_2_0_1()); }
+ )
+ { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__WildcardAssignment_2_0_3_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0()); }
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0()); }
+ '*'
+ { after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0()); }
+ )
+ { after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__MemberNameAssignment_2_0_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_2_0_3_1_0()); }
+ ruleValidID
+ { after(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_2_0_3_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__ImportedTypeAssignment_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_1_0()); }
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_2_1_0_1()); }
+ ruleQualifiedName
+ { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_2_1_0_1()); }
+ )
+ { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__ImportedNamespaceAssignment_2_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0()); }
+ ruleQualifiedNameWithWildcard
+ { after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__FqnImportAssignment_2_3_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0()); }
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0()); }
+ 'ns'
+ { after(grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0()); }
+ )
+ { after(grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0()); }
+ ruleQualifiedName
+ { after(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__AnnotationTypeAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeCrossReference_2_0()); }
+ (
+ { before(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeQualifiedNameParserRuleCall_2_0_1()); }
+ ruleQualifiedName
+ { after(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeQualifiedNameParserRuleCall_2_0_1()); }
+ )
+ { after(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeCrossReference_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_0_0()); }
+ ruleXAnnotationElementValuePair
+ { after(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_1_1_0()); }
+ ruleXAnnotationElementValuePair
+ { after(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__ValueAssignment_3_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAnnotationAccess().getValueXAnnotationElementValueOrCommaListParserRuleCall_3_1_1_0()); }
+ ruleXAnnotationElementValueOrCommaList
+ { after(grammarAccess.getXAnnotationAccess().getValueXAnnotationElementValueOrCommaListParserRuleCall_3_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__ElementAssignment_0_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationCrossReference_0_0_0_0()); }
+ (
+ { before(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationValidIDParserRuleCall_0_0_0_0_1()); }
+ ruleValidID
+ { after(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationValidIDParserRuleCall_0_0_0_0_1()); }
+ )
+ { after(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationCrossReference_0_0_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__ValueAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAnnotationElementValuePairAccess().getValueXAnnotationElementValueParserRuleCall_1_0()); }
+ ruleXAnnotationElementValue
+ { after(grammarAccess.getXAnnotationElementValuePairAccess().getValueXAnnotationElementValueParserRuleCall_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0()); }
+ ruleXAnnotationOrExpression
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0()); }
+ ruleXAnnotationOrExpression
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_1_1_1_1_0()); }
+ ruleXAnnotationOrExpression
+ { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_1_1_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__ElementsAssignment_0_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0()); }
+ ruleXAnnotationOrExpression
+ { after(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0()); }
+ ruleXAnnotationOrExpression
+ { after(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__FeatureAssignment_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); }
+ (
+ { before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); }
+ ruleFeatureCallID
+ { after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); }
+ )
+ { after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__ValueAssignment_0_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); }
+ ruleXAssignment
+ { after(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__FeatureAssignment_1_1_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); }
+ (
+ { before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); }
+ ruleOpMultiAssign
+ { after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); }
+ )
+ { after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__RightOperandAssignment_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); }
+ ruleXAssignment
+ { after(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__FeatureAssignment_1_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+ (
+ { before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); }
+ ruleOpOr
+ { after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); }
+ )
+ { after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__RightOperandAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); }
+ ruleXAndExpression
+ { after(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__FeatureAssignment_1_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+ (
+ { before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); }
+ ruleOpAnd
+ { after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); }
+ )
+ { after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__RightOperandAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); }
+ ruleXEqualityExpression
+ { after(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__FeatureAssignment_1_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+ (
+ { before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); }
+ ruleOpEquality
+ { after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); }
+ )
+ { after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__RightOperandAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); }
+ ruleXRelationalExpression
+ { after(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__TypeAssignment_1_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); }
+ ruleJvmTypeReference
+ { after(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); }
+ (
+ { before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); }
+ ruleOpCompare
+ { after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); }
+ )
+ { after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__RightOperandAssignment_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); }
+ ruleXOtherOperatorExpression
+ { after(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+ (
+ { before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); }
+ ruleOpOther
+ { after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); }
+ )
+ { after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__RightOperandAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); }
+ ruleXAdditiveExpression
+ { after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__FeatureAssignment_1_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+ (
+ { before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); }
+ ruleOpAdd
+ { after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); }
+ )
+ { after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__RightOperandAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); }
+ ruleXMultiplicativeExpression
+ { after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+ (
+ { before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); }
+ ruleOpMulti
+ { after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); }
+ )
+ { after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__RightOperandAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); }
+ ruleXUnaryOperation
+ { after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XUnaryOperation__FeatureAssignment_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); }
+ (
+ { before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); }
+ ruleOpUnary
+ { after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); }
+ )
+ { after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XUnaryOperation__OperandAssignment_0_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); }
+ ruleXUnaryOperation
+ { after(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__TypeAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); }
+ ruleJvmTypeReference
+ { after(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XPostfixOperation__FeatureAssignment_1_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); }
+ (
+ { before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); }
+ ruleOpPostfix
+ { after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); }
+ )
+ { after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); }
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); }
+ '::'
+ { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); }
+ )
+ { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); }
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); }
+ ruleFeatureCallID
+ { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); }
+ )
+ { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__ValueAssignment_1_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); }
+ ruleXAssignment
+ { after(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); }
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); }
+ '?.'
+ { after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); }
+ )
+ { after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); }
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); }
+ '::'
+ { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); }
+ )
+ { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); }
+ ruleJvmArgumentTypeReference
+ { after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); }
+ ruleJvmArgumentTypeReference
+ { after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__FeatureAssignment_1_1_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); }
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); }
+ ruleIdOrSuper
+ { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); }
+ )
+ { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); }
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); }
+ '('
+ { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); }
+ )
+ { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); }
+ ruleXShortClosure
+ { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); }
+ ruleXClosure
+ { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__ElementsAssignment_3_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__ElementsAssignment_3_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__ElementsAssignment_3_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__ElementsAssignment_3_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); }
+ ruleJvmFormalParameter
+ { after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); }
+ ruleJvmFormalParameter
+ { after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__ExplicitSyntaxAssignment_1_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); }
+ (
+ { before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); }
+ '|'
+ { after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); }
+ )
+ { after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XClosure__ExpressionAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); }
+ ruleXExpressionInClosure
+ { after(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XExpressionInClosure__ExpressionsAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); }
+ ruleXExpressionOrVarDeclaration
+ { after(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); }
+ ruleJvmFormalParameter
+ { after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); }
+ ruleJvmFormalParameter
+ { after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); }
+ (
+ { before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); }
+ '|'
+ { after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); }
+ )
+ { after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__ExpressionAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__IfAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__ThenAssignment_5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__ElseAssignment_6_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); }
+ ruleJvmFormalParameter
+ { after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__SwitchAssignment_2_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); }
+ ruleJvmFormalParameter
+ { after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__SwitchAssignment_2_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__CasesAssignment_4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); }
+ ruleXCasePart
+ { after(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__DefaultAssignment_5_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__TypeGuardAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); }
+ ruleJvmTypeReference
+ { after(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__CaseAssignment_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__ThenAssignment_3_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__FallThroughAssignment_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); }
+ (
+ { before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); }
+ ','
+ { after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); }
+ )
+ { after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__DeclaredParamAssignment_0_0_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); }
+ ruleJvmFormalParameter
+ { after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__ForExpressionAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__EachExpressionAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); }
+ ruleXExpressionOrVarDeclaration
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); }
+ ruleXExpressionOrVarDeclaration
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__ExpressionAssignment_5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__EachExpressionAssignment_9
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__PredicateAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__BodyAssignment_5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__BodyAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__PredicateAssignment_5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__ExpressionsAssignment_2_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); }
+ ruleXExpressionOrVarDeclaration
+ { after(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__WriteableAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); }
+ (
+ { before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); }
+ 'var'
+ { after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); }
+ )
+ { after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__TypeAssignment_2_0_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); }
+ ruleJvmTypeReference
+ { after(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__NameAssignment_2_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); }
+ ruleValidID
+ { after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__NameAssignment_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); }
+ ruleValidID
+ { after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__RightAssignment_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmFormalParameter__ParameterTypeAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); }
+ ruleJvmTypeReference
+ { after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmFormalParameter__NameAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); }
+ ruleValidID
+ { after(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__FullJvmFormalParameter__ParameterTypeAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); }
+ ruleJvmTypeReference
+ { after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__FullJvmFormalParameter__NameAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); }
+ ruleValidID
+ { after(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__TypeArgumentsAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); }
+ ruleJvmArgumentTypeReference
+ { after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__TypeArgumentsAssignment_1_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); }
+ ruleJvmArgumentTypeReference
+ { after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__FeatureAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); }
+ (
+ { before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); }
+ ruleIdOrSuper
+ { after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); }
+ )
+ { after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__ExplicitOperationCallAssignment_3_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); }
+ (
+ { before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); }
+ '('
+ { after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); }
+ )
+ { after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); }
+ ruleXShortClosure
+ { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__FeatureCallArgumentsAssignment_4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); }
+ ruleXClosure
+ { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__ConstructorAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); }
+ (
+ { before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); }
+ ruleQualifiedName
+ { after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); }
+ )
+ { after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__TypeArgumentsAssignment_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); }
+ ruleJvmArgumentTypeReference
+ { after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__TypeArgumentsAssignment_3_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); }
+ ruleJvmArgumentTypeReference
+ { after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); }
+ (
+ { before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); }
+ '('
+ { after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); }
+ )
+ { after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__ArgumentsAssignment_4_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); }
+ ruleXShortClosure
+ { after(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__ArgumentsAssignment_4_1_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__ArgumentsAssignment_5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); }
+ ruleXClosure
+ { after(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBooleanLiteral__IsTrueAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); }
+ (
+ { before(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); }
+ 'true'
+ { after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); }
+ )
+ { after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XNumberLiteral__ValueAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); }
+ ruleNumber
+ { after(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XStringLiteral__ValueAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); }
+ RULE_STRING
+ { after(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__TypeAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); }
+ (
+ { before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); }
+ ruleQualifiedName
+ { after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); }
+ )
+ { after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__ArrayDimensionsAssignment_4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); }
+ ruleArrayBrackets
+ { after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XThrowExpression__ExpressionAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XReturnExpression__ExpressionAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__ExpressionAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); }
+ ruleXCatchClause
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__ParamAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__ExpressionAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__DeclaredParamAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); }
+ ruleFullJvmFormalParameter
+ { after(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__ExpressionAssignment_4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); }
+ ruleXExpression
+ { after(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); }
+ ruleJvmTypeReference
+ { after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); }
+ ruleJvmTypeReference
+ { after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__ReturnTypeAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); }
+ ruleJvmTypeReference
+ { after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__TypeAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); }
+ (
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); }
+ ruleQualifiedName
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); }
+ )
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); }
+ ruleJvmArgumentTypeReference
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); }
+ ruleJvmArgumentTypeReference
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); }
+ (
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); }
+ ruleValidID
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); }
+ )
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); }
+ ruleJvmArgumentTypeReference
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); }
+ ruleJvmArgumentTypeReference
+ { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); }
+ ruleJvmUpperBound
+ { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); }
+ ruleJvmUpperBoundAnded
+ { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); }
+ ruleJvmLowerBound
+ { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); }
+ ruleJvmLowerBoundAnded
+ { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmUpperBound__TypeReferenceAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); }
+ ruleJvmTypeReference
+ { after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmUpperBoundAnded__TypeReferenceAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); }
+ ruleJvmTypeReference
+ { after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmLowerBound__TypeReferenceAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); }
+ ruleJvmTypeReference
+ { after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmLowerBoundAnded__TypeReferenceAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ (
+ { before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); }
+ ruleJvmTypeReference
+ { after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); }
+ )
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+RULE_HEX : ('0x'|'0X') ('0'..'9'|'a'..'f'|'A'..'F'|'_')+ ('#' (('b'|'B') ('i'|'I')|('l'|'L')))?;
+
+RULE_INT : '0'..'9' ('0'..'9'|'_')*;
+
+RULE_DECIMAL : RULE_INT (('e'|'E') ('+'|'-')? RULE_INT)? (('b'|'B') ('i'|'I'|'d'|'D')|('l'|'L'|'d'|'D'|'f'|'F'))?;
+
+RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'$'|'_') ('a'..'z'|'A'..'Z'|'$'|'_'|'0'..'9')*;
+
+RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'?|'\'' ('\\' .|~(('\\'|'\'')))* '\''?);
+
+RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/';
+
+RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?;
+
+RULE_WS : (' '|'\t'|'\r'|'\n')+;
+
+RULE_ANY_OTHER : .;
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtype.tokens b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtype.tokens
new file mode 100644
index 0000000..492b3ba
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtype.tokens
@@ -0,0 +1,161 @@
+'!'=40
+'!='=22
+'!=='=24
+'#'=57
+'%'=39
+'%='=20
+'&&'=15
+'&'=82
+'('=53
+')'=54
+'*'=36
+'**'=37
+'*='=18
+'+'=34
+'++'=41
+'+='=16
+','=55
+'-'=35
+'--'=42
+'-='=17
+'->'=28
+'.'=43
+'..'=30
+'..<'=29
+'/'=38
+'/='=19
+':'=66
+'::'=84
+';'=51
+'<'=27
+'<>'=32
+'='=13
+'=='=21
+'==='=23
+'=>'=31
+'>'=26
+'>='=25
+'?'=81
+'?.'=85
+'?:'=33
+'@'=52
+'['=58
+']'=56
+'as'=60
+'case'=68
+'catch'=80
+'default'=67
+'do'=71
+'else'=64
+'extends'=45
+'extension'=48
+'false'=50
+'finally'=78
+'for'=69
+'if'=63
+'import'=47
+'instanceof'=59
+'new'=72
+'ns'=83
+'null'=73
+'return'=76
+'static'=46
+'super'=49
+'switch'=65
+'synchronized'=79
+'throw'=75
+'true'=88
+'try'=77
+'typeof'=74
+'val'=44
+'var'=87
+'while'=70
+'{'=61
+'|'=86
+'||'=14
+'}'=62
+RULE_ANY_OTHER=12
+RULE_DECIMAL=7
+RULE_HEX=5
+RULE_ID=4
+RULE_INT=6
+RULE_ML_COMMENT=9
+RULE_SL_COMMENT=10
+RULE_STRING=8
+RULE_WS=11
+T__13=13
+T__14=14
+T__15=15
+T__16=16
+T__17=17
+T__18=18
+T__19=19
+T__20=20
+T__21=21
+T__22=22
+T__23=23
+T__24=24
+T__25=25
+T__26=26
+T__27=27
+T__28=28
+T__29=29
+T__30=30
+T__31=31
+T__32=32
+T__33=33
+T__34=34
+T__35=35
+T__36=36
+T__37=37
+T__38=38
+T__39=39
+T__40=40
+T__41=41
+T__42=42
+T__43=43
+T__44=44
+T__45=45
+T__46=46
+T__47=47
+T__48=48
+T__49=49
+T__50=50
+T__51=51
+T__52=52
+T__53=53
+T__54=54
+T__55=55
+T__56=56
+T__57=57
+T__58=58
+T__59=59
+T__60=60
+T__61=61
+T__62=62
+T__63=63
+T__64=64
+T__65=65
+T__66=66
+T__67=67
+T__68=68
+T__69=69
+T__70=70
+T__71=71
+T__72=72
+T__73=73
+T__74=74
+T__75=75
+T__76=76
+T__77=77
+T__78=78
+T__79=79
+T__80=80
+T__81=81
+T__82=82
+T__83=83
+T__84=84
+T__85=85
+T__86=86
+T__87=87
+T__88=88
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtypeLexer.java b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtypeLexer.java
new file mode 100644
index 0000000..d490114
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtypeLexer.java
@@ -0,0 +1,3533 @@
+package org.eclipse.osbp.xtext.oxtype.ide.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.ide.editor.contentassist.antlr.internal.Lexer;
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+
+@SuppressWarnings("all")
+public class InternalOXtypeLexer extends Lexer {
+ public static final int RULE_HEX=5;
+ public static final int T__50=50;
+ public static final int T__19=19;
+ public static final int T__15=15;
+ public static final int T__59=59;
+ public static final int T__16=16;
+ public static final int T__17=17;
+ public static final int T__18=18;
+ public static final int T__55=55;
+ public static final int T__56=56;
+ public static final int T__13=13;
+ public static final int T__57=57;
+ public static final int T__14=14;
+ public static final int T__58=58;
+ public static final int T__51=51;
+ public static final int T__52=52;
+ public static final int T__53=53;
+ public static final int T__54=54;
+ public static final int T__60=60;
+ public static final int T__61=61;
+ public static final int RULE_ID=4;
+ public static final int RULE_DECIMAL=7;
+ public static final int T__26=26;
+ public static final int T__27=27;
+ public static final int T__28=28;
+ public static final int RULE_INT=6;
+ public static final int T__29=29;
+ public static final int T__22=22;
+ public static final int T__66=66;
+ public static final int RULE_ML_COMMENT=9;
+ public static final int T__23=23;
+ public static final int T__67=67;
+ public static final int T__24=24;
+ public static final int T__68=68;
+ public static final int T__25=25;
+ public static final int T__69=69;
+ public static final int T__62=62;
+ public static final int T__63=63;
+ public static final int T__20=20;
+ public static final int T__64=64;
+ public static final int T__21=21;
+ public static final int T__65=65;
+ public static final int T__70=70;
+ public static final int T__71=71;
+ public static final int T__72=72;
+ public static final int RULE_STRING=8;
+ public static final int RULE_SL_COMMENT=10;
+ public static final int T__37=37;
+ public static final int T__38=38;
+ public static final int T__39=39;
+ public static final int T__33=33;
+ public static final int T__77=77;
+ public static final int T__34=34;
+ public static final int T__78=78;
+ public static final int T__35=35;
+ public static final int T__79=79;
+ public static final int T__36=36;
+ public static final int T__73=73;
+ public static final int EOF=-1;
+ public static final int T__30=30;
+ public static final int T__74=74;
+ public static final int T__31=31;
+ public static final int T__75=75;
+ public static final int T__32=32;
+ public static final int T__76=76;
+ public static final int T__80=80;
+ public static final int T__81=81;
+ public static final int T__82=82;
+ public static final int T__83=83;
+ public static final int RULE_WS=11;
+ public static final int RULE_ANY_OTHER=12;
+ public static final int T__48=48;
+ public static final int T__49=49;
+ public static final int T__44=44;
+ public static final int T__88=88;
+ public static final int T__45=45;
+ public static final int T__46=46;
+ public static final int T__47=47;
+ public static final int T__40=40;
+ public static final int T__84=84;
+ public static final int T__41=41;
+ public static final int T__85=85;
+ public static final int T__42=42;
+ public static final int T__86=86;
+ public static final int T__43=43;
+ public static final int T__87=87;
+
+ // delegates
+ // delegators
+
+ public InternalOXtypeLexer() {;}
+ public InternalOXtypeLexer(CharStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public InternalOXtypeLexer(CharStream input, RecognizerSharedState state) {
+ super(input,state);
+
+ }
+ public String getGrammarFileName() { return "InternalOXtype.g"; }
+
+ // $ANTLR start "T__13"
+ public final void mT__13() throws RecognitionException {
+ try {
+ int _type = T__13;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:11:7: ( '=' )
+ // InternalOXtype.g:11:9: '='
+ {
+ match('=');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__13"
+
+ // $ANTLR start "T__14"
+ public final void mT__14() throws RecognitionException {
+ try {
+ int _type = T__14;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:12:7: ( '||' )
+ // InternalOXtype.g:12:9: '||'
+ {
+ match("||");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__14"
+
+ // $ANTLR start "T__15"
+ public final void mT__15() throws RecognitionException {
+ try {
+ int _type = T__15;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:13:7: ( '&&' )
+ // InternalOXtype.g:13:9: '&&'
+ {
+ match("&&");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__15"
+
+ // $ANTLR start "T__16"
+ public final void mT__16() throws RecognitionException {
+ try {
+ int _type = T__16;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:14:7: ( '+=' )
+ // InternalOXtype.g:14:9: '+='
+ {
+ match("+=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__16"
+
+ // $ANTLR start "T__17"
+ public final void mT__17() throws RecognitionException {
+ try {
+ int _type = T__17;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:15:7: ( '-=' )
+ // InternalOXtype.g:15:9: '-='
+ {
+ match("-=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__17"
+
+ // $ANTLR start "T__18"
+ public final void mT__18() throws RecognitionException {
+ try {
+ int _type = T__18;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:16:7: ( '*=' )
+ // InternalOXtype.g:16:9: '*='
+ {
+ match("*=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__18"
+
+ // $ANTLR start "T__19"
+ public final void mT__19() throws RecognitionException {
+ try {
+ int _type = T__19;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:17:7: ( '/=' )
+ // InternalOXtype.g:17:9: '/='
+ {
+ match("/=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__19"
+
+ // $ANTLR start "T__20"
+ public final void mT__20() throws RecognitionException {
+ try {
+ int _type = T__20;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:18:7: ( '%=' )
+ // InternalOXtype.g:18:9: '%='
+ {
+ match("%=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__20"
+
+ // $ANTLR start "T__21"
+ public final void mT__21() throws RecognitionException {
+ try {
+ int _type = T__21;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:19:7: ( '==' )
+ // InternalOXtype.g:19:9: '=='
+ {
+ match("==");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__21"
+
+ // $ANTLR start "T__22"
+ public final void mT__22() throws RecognitionException {
+ try {
+ int _type = T__22;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:20:7: ( '!=' )
+ // InternalOXtype.g:20:9: '!='
+ {
+ match("!=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__22"
+
+ // $ANTLR start "T__23"
+ public final void mT__23() throws RecognitionException {
+ try {
+ int _type = T__23;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:21:7: ( '===' )
+ // InternalOXtype.g:21:9: '==='
+ {
+ match("===");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__23"
+
+ // $ANTLR start "T__24"
+ public final void mT__24() throws RecognitionException {
+ try {
+ int _type = T__24;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:22:7: ( '!==' )
+ // InternalOXtype.g:22:9: '!=='
+ {
+ match("!==");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__24"
+
+ // $ANTLR start "T__25"
+ public final void mT__25() throws RecognitionException {
+ try {
+ int _type = T__25;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:23:7: ( '>=' )
+ // InternalOXtype.g:23:9: '>='
+ {
+ match(">=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__25"
+
+ // $ANTLR start "T__26"
+ public final void mT__26() throws RecognitionException {
+ try {
+ int _type = T__26;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:24:7: ( '>' )
+ // InternalOXtype.g:24:9: '>'
+ {
+ match('>');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__26"
+
+ // $ANTLR start "T__27"
+ public final void mT__27() throws RecognitionException {
+ try {
+ int _type = T__27;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:25:7: ( '<' )
+ // InternalOXtype.g:25:9: '<'
+ {
+ match('<');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__27"
+
+ // $ANTLR start "T__28"
+ public final void mT__28() throws RecognitionException {
+ try {
+ int _type = T__28;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:26:7: ( '->' )
+ // InternalOXtype.g:26:9: '->'
+ {
+ match("->");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__28"
+
+ // $ANTLR start "T__29"
+ public final void mT__29() throws RecognitionException {
+ try {
+ int _type = T__29;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:27:7: ( '..<' )
+ // InternalOXtype.g:27:9: '..<'
+ {
+ match("..<");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__29"
+
+ // $ANTLR start "T__30"
+ public final void mT__30() throws RecognitionException {
+ try {
+ int _type = T__30;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:28:7: ( '..' )
+ // InternalOXtype.g:28:9: '..'
+ {
+ match("..");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__30"
+
+ // $ANTLR start "T__31"
+ public final void mT__31() throws RecognitionException {
+ try {
+ int _type = T__31;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:29:7: ( '=>' )
+ // InternalOXtype.g:29:9: '=>'
+ {
+ match("=>");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__31"
+
+ // $ANTLR start "T__32"
+ public final void mT__32() throws RecognitionException {
+ try {
+ int _type = T__32;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:30:7: ( '<>' )
+ // InternalOXtype.g:30:9: '<>'
+ {
+ match("<>");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__32"
+
+ // $ANTLR start "T__33"
+ public final void mT__33() throws RecognitionException {
+ try {
+ int _type = T__33;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:31:7: ( '?:' )
+ // InternalOXtype.g:31:9: '?:'
+ {
+ match("?:");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__33"
+
+ // $ANTLR start "T__34"
+ public final void mT__34() throws RecognitionException {
+ try {
+ int _type = T__34;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:32:7: ( '+' )
+ // InternalOXtype.g:32:9: '+'
+ {
+ match('+');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__34"
+
+ // $ANTLR start "T__35"
+ public final void mT__35() throws RecognitionException {
+ try {
+ int _type = T__35;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:33:7: ( '-' )
+ // InternalOXtype.g:33:9: '-'
+ {
+ match('-');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__35"
+
+ // $ANTLR start "T__36"
+ public final void mT__36() throws RecognitionException {
+ try {
+ int _type = T__36;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:34:7: ( '*' )
+ // InternalOXtype.g:34:9: '*'
+ {
+ match('*');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__36"
+
+ // $ANTLR start "T__37"
+ public final void mT__37() throws RecognitionException {
+ try {
+ int _type = T__37;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:35:7: ( '**' )
+ // InternalOXtype.g:35:9: '**'
+ {
+ match("**");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__37"
+
+ // $ANTLR start "T__38"
+ public final void mT__38() throws RecognitionException {
+ try {
+ int _type = T__38;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:36:7: ( '/' )
+ // InternalOXtype.g:36:9: '/'
+ {
+ match('/');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__38"
+
+ // $ANTLR start "T__39"
+ public final void mT__39() throws RecognitionException {
+ try {
+ int _type = T__39;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:37:7: ( '%' )
+ // InternalOXtype.g:37:9: '%'
+ {
+ match('%');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__39"
+
+ // $ANTLR start "T__40"
+ public final void mT__40() throws RecognitionException {
+ try {
+ int _type = T__40;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:38:7: ( '!' )
+ // InternalOXtype.g:38:9: '!'
+ {
+ match('!');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__40"
+
+ // $ANTLR start "T__41"
+ public final void mT__41() throws RecognitionException {
+ try {
+ int _type = T__41;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:39:7: ( '++' )
+ // InternalOXtype.g:39:9: '++'
+ {
+ match("++");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__41"
+
+ // $ANTLR start "T__42"
+ public final void mT__42() throws RecognitionException {
+ try {
+ int _type = T__42;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:40:7: ( '--' )
+ // InternalOXtype.g:40:9: '--'
+ {
+ match("--");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__42"
+
+ // $ANTLR start "T__43"
+ public final void mT__43() throws RecognitionException {
+ try {
+ int _type = T__43;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:41:7: ( '.' )
+ // InternalOXtype.g:41:9: '.'
+ {
+ match('.');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__43"
+
+ // $ANTLR start "T__44"
+ public final void mT__44() throws RecognitionException {
+ try {
+ int _type = T__44;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:42:7: ( 'val' )
+ // InternalOXtype.g:42:9: 'val'
+ {
+ match("val");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__44"
+
+ // $ANTLR start "T__45"
+ public final void mT__45() throws RecognitionException {
+ try {
+ int _type = T__45;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:43:7: ( 'extends' )
+ // InternalOXtype.g:43:9: 'extends'
+ {
+ match("extends");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__45"
+
+ // $ANTLR start "T__46"
+ public final void mT__46() throws RecognitionException {
+ try {
+ int _type = T__46;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:44:7: ( 'static' )
+ // InternalOXtype.g:44:9: 'static'
+ {
+ match("static");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__46"
+
+ // $ANTLR start "T__47"
+ public final void mT__47() throws RecognitionException {
+ try {
+ int _type = T__47;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:45:7: ( 'import' )
+ // InternalOXtype.g:45:9: 'import'
+ {
+ match("import");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__47"
+
+ // $ANTLR start "T__48"
+ public final void mT__48() throws RecognitionException {
+ try {
+ int _type = T__48;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:46:7: ( 'extension' )
+ // InternalOXtype.g:46:9: 'extension'
+ {
+ match("extension");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__48"
+
+ // $ANTLR start "T__49"
+ public final void mT__49() throws RecognitionException {
+ try {
+ int _type = T__49;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:47:7: ( 'super' )
+ // InternalOXtype.g:47:9: 'super'
+ {
+ match("super");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__49"
+
+ // $ANTLR start "T__50"
+ public final void mT__50() throws RecognitionException {
+ try {
+ int _type = T__50;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:48:7: ( 'false' )
+ // InternalOXtype.g:48:9: 'false'
+ {
+ match("false");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__50"
+
+ // $ANTLR start "T__51"
+ public final void mT__51() throws RecognitionException {
+ try {
+ int _type = T__51;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:49:7: ( ';' )
+ // InternalOXtype.g:49:9: ';'
+ {
+ match(';');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__51"
+
+ // $ANTLR start "T__52"
+ public final void mT__52() throws RecognitionException {
+ try {
+ int _type = T__52;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:50:7: ( '@' )
+ // InternalOXtype.g:50:9: '@'
+ {
+ match('@');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__52"
+
+ // $ANTLR start "T__53"
+ public final void mT__53() throws RecognitionException {
+ try {
+ int _type = T__53;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:51:7: ( '(' )
+ // InternalOXtype.g:51:9: '('
+ {
+ match('(');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__53"
+
+ // $ANTLR start "T__54"
+ public final void mT__54() throws RecognitionException {
+ try {
+ int _type = T__54;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:52:7: ( ')' )
+ // InternalOXtype.g:52:9: ')'
+ {
+ match(')');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__54"
+
+ // $ANTLR start "T__55"
+ public final void mT__55() throws RecognitionException {
+ try {
+ int _type = T__55;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:53:7: ( ',' )
+ // InternalOXtype.g:53:9: ','
+ {
+ match(',');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__55"
+
+ // $ANTLR start "T__56"
+ public final void mT__56() throws RecognitionException {
+ try {
+ int _type = T__56;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:54:7: ( ']' )
+ // InternalOXtype.g:54:9: ']'
+ {
+ match(']');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__56"
+
+ // $ANTLR start "T__57"
+ public final void mT__57() throws RecognitionException {
+ try {
+ int _type = T__57;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:55:7: ( '#' )
+ // InternalOXtype.g:55:9: '#'
+ {
+ match('#');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__57"
+
+ // $ANTLR start "T__58"
+ public final void mT__58() throws RecognitionException {
+ try {
+ int _type = T__58;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:56:7: ( '[' )
+ // InternalOXtype.g:56:9: '['
+ {
+ match('[');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__58"
+
+ // $ANTLR start "T__59"
+ public final void mT__59() throws RecognitionException {
+ try {
+ int _type = T__59;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:57:7: ( 'instanceof' )
+ // InternalOXtype.g:57:9: 'instanceof'
+ {
+ match("instanceof");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__59"
+
+ // $ANTLR start "T__60"
+ public final void mT__60() throws RecognitionException {
+ try {
+ int _type = T__60;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:58:7: ( 'as' )
+ // InternalOXtype.g:58:9: 'as'
+ {
+ match("as");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__60"
+
+ // $ANTLR start "T__61"
+ public final void mT__61() throws RecognitionException {
+ try {
+ int _type = T__61;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:59:7: ( '{' )
+ // InternalOXtype.g:59:9: '{'
+ {
+ match('{');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__61"
+
+ // $ANTLR start "T__62"
+ public final void mT__62() throws RecognitionException {
+ try {
+ int _type = T__62;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:60:7: ( '}' )
+ // InternalOXtype.g:60:9: '}'
+ {
+ match('}');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__62"
+
+ // $ANTLR start "T__63"
+ public final void mT__63() throws RecognitionException {
+ try {
+ int _type = T__63;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:61:7: ( 'if' )
+ // InternalOXtype.g:61:9: 'if'
+ {
+ match("if");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__63"
+
+ // $ANTLR start "T__64"
+ public final void mT__64() throws RecognitionException {
+ try {
+ int _type = T__64;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:62:7: ( 'else' )
+ // InternalOXtype.g:62:9: 'else'
+ {
+ match("else");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__64"
+
+ // $ANTLR start "T__65"
+ public final void mT__65() throws RecognitionException {
+ try {
+ int _type = T__65;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:63:7: ( 'switch' )
+ // InternalOXtype.g:63:9: 'switch'
+ {
+ match("switch");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__65"
+
+ // $ANTLR start "T__66"
+ public final void mT__66() throws RecognitionException {
+ try {
+ int _type = T__66;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:64:7: ( ':' )
+ // InternalOXtype.g:64:9: ':'
+ {
+ match(':');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__66"
+
+ // $ANTLR start "T__67"
+ public final void mT__67() throws RecognitionException {
+ try {
+ int _type = T__67;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:65:7: ( 'default' )
+ // InternalOXtype.g:65:9: 'default'
+ {
+ match("default");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__67"
+
+ // $ANTLR start "T__68"
+ public final void mT__68() throws RecognitionException {
+ try {
+ int _type = T__68;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:66:7: ( 'case' )
+ // InternalOXtype.g:66:9: 'case'
+ {
+ match("case");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__68"
+
+ // $ANTLR start "T__69"
+ public final void mT__69() throws RecognitionException {
+ try {
+ int _type = T__69;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:67:7: ( 'for' )
+ // InternalOXtype.g:67:9: 'for'
+ {
+ match("for");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__69"
+
+ // $ANTLR start "T__70"
+ public final void mT__70() throws RecognitionException {
+ try {
+ int _type = T__70;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:68:7: ( 'while' )
+ // InternalOXtype.g:68:9: 'while'
+ {
+ match("while");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__70"
+
+ // $ANTLR start "T__71"
+ public final void mT__71() throws RecognitionException {
+ try {
+ int _type = T__71;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:69:7: ( 'do' )
+ // InternalOXtype.g:69:9: 'do'
+ {
+ match("do");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__71"
+
+ // $ANTLR start "T__72"
+ public final void mT__72() throws RecognitionException {
+ try {
+ int _type = T__72;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:70:7: ( 'new' )
+ // InternalOXtype.g:70:9: 'new'
+ {
+ match("new");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__72"
+
+ // $ANTLR start "T__73"
+ public final void mT__73() throws RecognitionException {
+ try {
+ int _type = T__73;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:71:7: ( 'null' )
+ // InternalOXtype.g:71:9: 'null'
+ {
+ match("null");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__73"
+
+ // $ANTLR start "T__74"
+ public final void mT__74() throws RecognitionException {
+ try {
+ int _type = T__74;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:72:7: ( 'typeof' )
+ // InternalOXtype.g:72:9: 'typeof'
+ {
+ match("typeof");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__74"
+
+ // $ANTLR start "T__75"
+ public final void mT__75() throws RecognitionException {
+ try {
+ int _type = T__75;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:73:7: ( 'throw' )
+ // InternalOXtype.g:73:9: 'throw'
+ {
+ match("throw");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__75"
+
+ // $ANTLR start "T__76"
+ public final void mT__76() throws RecognitionException {
+ try {
+ int _type = T__76;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:74:7: ( 'return' )
+ // InternalOXtype.g:74:9: 'return'
+ {
+ match("return");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__76"
+
+ // $ANTLR start "T__77"
+ public final void mT__77() throws RecognitionException {
+ try {
+ int _type = T__77;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:75:7: ( 'try' )
+ // InternalOXtype.g:75:9: 'try'
+ {
+ match("try");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__77"
+
+ // $ANTLR start "T__78"
+ public final void mT__78() throws RecognitionException {
+ try {
+ int _type = T__78;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:76:7: ( 'finally' )
+ // InternalOXtype.g:76:9: 'finally'
+ {
+ match("finally");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__78"
+
+ // $ANTLR start "T__79"
+ public final void mT__79() throws RecognitionException {
+ try {
+ int _type = T__79;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:77:7: ( 'synchronized' )
+ // InternalOXtype.g:77:9: 'synchronized'
+ {
+ match("synchronized");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__79"
+
+ // $ANTLR start "T__80"
+ public final void mT__80() throws RecognitionException {
+ try {
+ int _type = T__80;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:78:7: ( 'catch' )
+ // InternalOXtype.g:78:9: 'catch'
+ {
+ match("catch");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__80"
+
+ // $ANTLR start "T__81"
+ public final void mT__81() throws RecognitionException {
+ try {
+ int _type = T__81;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:79:7: ( '?' )
+ // InternalOXtype.g:79:9: '?'
+ {
+ match('?');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__81"
+
+ // $ANTLR start "T__82"
+ public final void mT__82() throws RecognitionException {
+ try {
+ int _type = T__82;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:80:7: ( '&' )
+ // InternalOXtype.g:80:9: '&'
+ {
+ match('&');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__82"
+
+ // $ANTLR start "T__83"
+ public final void mT__83() throws RecognitionException {
+ try {
+ int _type = T__83;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:81:7: ( 'ns' )
+ // InternalOXtype.g:81:9: 'ns'
+ {
+ match("ns");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__83"
+
+ // $ANTLR start "T__84"
+ public final void mT__84() throws RecognitionException {
+ try {
+ int _type = T__84;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:82:7: ( '::' )
+ // InternalOXtype.g:82:9: '::'
+ {
+ match("::");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__84"
+
+ // $ANTLR start "T__85"
+ public final void mT__85() throws RecognitionException {
+ try {
+ int _type = T__85;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:83:7: ( '?.' )
+ // InternalOXtype.g:83:9: '?.'
+ {
+ match("?.");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__85"
+
+ // $ANTLR start "T__86"
+ public final void mT__86() throws RecognitionException {
+ try {
+ int _type = T__86;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:84:7: ( '|' )
+ // InternalOXtype.g:84:9: '|'
+ {
+ match('|');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__86"
+
+ // $ANTLR start "T__87"
+ public final void mT__87() throws RecognitionException {
+ try {
+ int _type = T__87;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:85:7: ( 'var' )
+ // InternalOXtype.g:85:9: 'var'
+ {
+ match("var");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__87"
+
+ // $ANTLR start "T__88"
+ public final void mT__88() throws RecognitionException {
+ try {
+ int _type = T__88;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:86:7: ( 'true' )
+ // InternalOXtype.g:86:9: 'true'
+ {
+ match("true");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__88"
+
+ // $ANTLR start "RULE_HEX"
+ public final void mRULE_HEX() throws RecognitionException {
+ try {
+ int _type = RULE_HEX;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:18598:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? )
+ // InternalOXtype.g:18598:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )?
+ {
+ // InternalOXtype.g:18598:12: ( '0x' | '0X' )
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( (LA1_0=='0') ) {
+ int LA1_1 = input.LA(2);
+
+ if ( (LA1_1=='x') ) {
+ alt1=1;
+ }
+ else if ( (LA1_1=='X') ) {
+ alt1=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 1, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 1, 0, input);
+
+ throw nvae;
+ }
+ switch (alt1) {
+ case 1 :
+ // InternalOXtype.g:18598:13: '0x'
+ {
+ match("0x");
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:18598:18: '0X'
+ {
+ match("0X");
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:18598:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+
+ int cnt2=0;
+ loop2:
+ do {
+ int alt2=2;
+ int LA2_0 = input.LA(1);
+
+ if ( ((LA2_0>='0' && LA2_0<='9')||(LA2_0>='A' && LA2_0<='F')||LA2_0=='_'||(LA2_0>='a' && LA2_0<='f')) ) {
+ alt2=1;
+ }
+
+
+ switch (alt2) {
+ case 1 :
+ // InternalOXtype.g:
+ {
+ if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='f') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ if ( cnt2 >= 1 ) break loop2;
+ EarlyExitException eee =
+ new EarlyExitException(2, input);
+ throw eee;
+ }
+ cnt2++;
+ } while (true);
+
+ // InternalOXtype.g:18598:58: ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )?
+ int alt4=2;
+ int LA4_0 = input.LA(1);
+
+ if ( (LA4_0=='#') ) {
+ alt4=1;
+ }
+ switch (alt4) {
+ case 1 :
+ // InternalOXtype.g:18598:59: '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) )
+ {
+ match('#');
+ // InternalOXtype.g:18598:63: ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) )
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( (LA3_0=='B'||LA3_0=='b') ) {
+ alt3=1;
+ }
+ else if ( (LA3_0=='L'||LA3_0=='l') ) {
+ alt3=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 3, 0, input);
+
+ throw nvae;
+ }
+ switch (alt3) {
+ case 1 :
+ // InternalOXtype.g:18598:64: ( 'b' | 'B' ) ( 'i' | 'I' )
+ {
+ if ( input.LA(1)=='B'||input.LA(1)=='b' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ if ( input.LA(1)=='I'||input.LA(1)=='i' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:18598:84: ( 'l' | 'L' )
+ {
+ if ( input.LA(1)=='L'||input.LA(1)=='l' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_HEX"
+
+ // $ANTLR start "RULE_INT"
+ public final void mRULE_INT() throws RecognitionException {
+ try {
+ int _type = RULE_INT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:18600:10: ( '0' .. '9' ( '0' .. '9' | '_' )* )
+ // InternalOXtype.g:18600:12: '0' .. '9' ( '0' .. '9' | '_' )*
+ {
+ matchRange('0','9');
+ // InternalOXtype.g:18600:21: ( '0' .. '9' | '_' )*
+ loop5:
+ do {
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( ((LA5_0>='0' && LA5_0<='9')||LA5_0=='_') ) {
+ alt5=1;
+ }
+
+
+ switch (alt5) {
+ case 1 :
+ // InternalOXtype.g:
+ {
+ if ( (input.LA(1)>='0' && input.LA(1)<='9')||input.LA(1)=='_' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop5;
+ }
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INT"
+
+ // $ANTLR start "RULE_DECIMAL"
+ public final void mRULE_DECIMAL() throws RecognitionException {
+ try {
+ int _type = RULE_DECIMAL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:18602:14: ( RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? )
+ // InternalOXtype.g:18602:16: RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )?
+ {
+ mRULE_INT();
+ // InternalOXtype.g:18602:25: ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )?
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( (LA7_0=='E'||LA7_0=='e') ) {
+ alt7=1;
+ }
+ switch (alt7) {
+ case 1 :
+ // InternalOXtype.g:18602:26: ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT
+ {
+ if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // InternalOXtype.g:18602:36: ( '+' | '-' )?
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( (LA6_0=='+'||LA6_0=='-') ) {
+ alt6=1;
+ }
+ switch (alt6) {
+ case 1 :
+ // InternalOXtype.g:
+ {
+ if ( input.LA(1)=='+'||input.LA(1)=='-' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ }
+
+ mRULE_INT();
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:18602:58: ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )?
+ int alt8=3;
+ int LA8_0 = input.LA(1);
+
+ if ( (LA8_0=='B'||LA8_0=='b') ) {
+ alt8=1;
+ }
+ else if ( (LA8_0=='D'||LA8_0=='F'||LA8_0=='L'||LA8_0=='d'||LA8_0=='f'||LA8_0=='l') ) {
+ alt8=2;
+ }
+ switch (alt8) {
+ case 1 :
+ // InternalOXtype.g:18602:59: ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' )
+ {
+ if ( input.LA(1)=='B'||input.LA(1)=='b' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ if ( input.LA(1)=='D'||input.LA(1)=='I'||input.LA(1)=='d'||input.LA(1)=='i' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:18602:87: ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' )
+ {
+ if ( input.LA(1)=='D'||input.LA(1)=='F'||input.LA(1)=='L'||input.LA(1)=='d'||input.LA(1)=='f'||input.LA(1)=='l' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_DECIMAL"
+
+ // $ANTLR start "RULE_ID"
+ public final void mRULE_ID() throws RecognitionException {
+ try {
+ int _type = RULE_ID;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:18604:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* )
+ // InternalOXtype.g:18604:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )*
+ {
+ // InternalOXtype.g:18604:11: ( '^' )?
+ int alt9=2;
+ int LA9_0 = input.LA(1);
+
+ if ( (LA9_0=='^') ) {
+ alt9=1;
+ }
+ switch (alt9) {
+ case 1 :
+ // InternalOXtype.g:18604:11: '^'
+ {
+ match('^');
+
+ }
+ break;
+
+ }
+
+ if ( input.LA(1)=='$'||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // InternalOXtype.g:18604:44: ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )*
+ loop10:
+ do {
+ int alt10=2;
+ int LA10_0 = input.LA(1);
+
+ if ( (LA10_0=='$'||(LA10_0>='0' && LA10_0<='9')||(LA10_0>='A' && LA10_0<='Z')||LA10_0=='_'||(LA10_0>='a' && LA10_0<='z')) ) {
+ alt10=1;
+ }
+
+
+ switch (alt10) {
+ case 1 :
+ // InternalOXtype.g:
+ {
+ if ( input.LA(1)=='$'||(input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop10;
+ }
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ID"
+
+ // $ANTLR start "RULE_STRING"
+ public final void mRULE_STRING() throws RecognitionException {
+ try {
+ int _type = RULE_STRING;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:18606:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) )
+ // InternalOXtype.g:18606:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? )
+ {
+ // InternalOXtype.g:18606:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? )
+ int alt15=2;
+ int LA15_0 = input.LA(1);
+
+ if ( (LA15_0=='\"') ) {
+ alt15=1;
+ }
+ else if ( (LA15_0=='\'') ) {
+ alt15=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 15, 0, input);
+
+ throw nvae;
+ }
+ switch (alt15) {
+ case 1 :
+ // InternalOXtype.g:18606:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )?
+ {
+ match('\"');
+ // InternalOXtype.g:18606:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
+ loop11:
+ do {
+ int alt11=3;
+ int LA11_0 = input.LA(1);
+
+ if ( (LA11_0=='\\') ) {
+ alt11=1;
+ }
+ else if ( ((LA11_0>='\u0000' && LA11_0<='!')||(LA11_0>='#' && LA11_0<='[')||(LA11_0>=']' && LA11_0<='\uFFFF')) ) {
+ alt11=2;
+ }
+
+
+ switch (alt11) {
+ case 1 :
+ // InternalOXtype.g:18606:21: '\\\\' .
+ {
+ match('\\');
+ matchAny();
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:18606:28: ~ ( ( '\\\\' | '\"' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop11;
+ }
+ } while (true);
+
+ // InternalOXtype.g:18606:44: ( '\"' )?
+ int alt12=2;
+ int LA12_0 = input.LA(1);
+
+ if ( (LA12_0=='\"') ) {
+ alt12=1;
+ }
+ switch (alt12) {
+ case 1 :
+ // InternalOXtype.g:18606:44: '\"'
+ {
+ match('\"');
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:18606:49: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )?
+ {
+ match('\'');
+ // InternalOXtype.g:18606:54: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )*
+ loop13:
+ do {
+ int alt13=3;
+ int LA13_0 = input.LA(1);
+
+ if ( (LA13_0=='\\') ) {
+ alt13=1;
+ }
+ else if ( ((LA13_0>='\u0000' && LA13_0<='&')||(LA13_0>='(' && LA13_0<='[')||(LA13_0>=']' && LA13_0<='\uFFFF')) ) {
+ alt13=2;
+ }
+
+
+ switch (alt13) {
+ case 1 :
+ // InternalOXtype.g:18606:55: '\\\\' .
+ {
+ match('\\');
+ matchAny();
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:18606:62: ~ ( ( '\\\\' | '\\'' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop13;
+ }
+ } while (true);
+
+ // InternalOXtype.g:18606:79: ( '\\'' )?
+ int alt14=2;
+ int LA14_0 = input.LA(1);
+
+ if ( (LA14_0=='\'') ) {
+ alt14=1;
+ }
+ switch (alt14) {
+ case 1 :
+ // InternalOXtype.g:18606:79: '\\''
+ {
+ match('\'');
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_STRING"
+
+ // $ANTLR start "RULE_ML_COMMENT"
+ public final void mRULE_ML_COMMENT() throws RecognitionException {
+ try {
+ int _type = RULE_ML_COMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:18608:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
+ // InternalOXtype.g:18608:19: '/*' ( options {greedy=false; } : . )* '*/'
+ {
+ match("/*");
+
+ // InternalOXtype.g:18608:24: ( options {greedy=false; } : . )*
+ loop16:
+ do {
+ int alt16=2;
+ int LA16_0 = input.LA(1);
+
+ if ( (LA16_0=='*') ) {
+ int LA16_1 = input.LA(2);
+
+ if ( (LA16_1=='/') ) {
+ alt16=2;
+ }
+ else if ( ((LA16_1>='\u0000' && LA16_1<='.')||(LA16_1>='0' && LA16_1<='\uFFFF')) ) {
+ alt16=1;
+ }
+
+
+ }
+ else if ( ((LA16_0>='\u0000' && LA16_0<=')')||(LA16_0>='+' && LA16_0<='\uFFFF')) ) {
+ alt16=1;
+ }
+
+
+ switch (alt16) {
+ case 1 :
+ // InternalOXtype.g:18608:52: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop16;
+ }
+ } while (true);
+
+ match("*/");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ML_COMMENT"
+
+ // $ANTLR start "RULE_SL_COMMENT"
+ public final void mRULE_SL_COMMENT() throws RecognitionException {
+ try {
+ int _type = RULE_SL_COMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:18610:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
+ // InternalOXtype.g:18610:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
+ {
+ match("//");
+
+ // InternalOXtype.g:18610:24: (~ ( ( '\\n' | '\\r' ) ) )*
+ loop17:
+ do {
+ int alt17=2;
+ int LA17_0 = input.LA(1);
+
+ if ( ((LA17_0>='\u0000' && LA17_0<='\t')||(LA17_0>='\u000B' && LA17_0<='\f')||(LA17_0>='\u000E' && LA17_0<='\uFFFF')) ) {
+ alt17=1;
+ }
+
+
+ switch (alt17) {
+ case 1 :
+ // InternalOXtype.g:18610:24: ~ ( ( '\\n' | '\\r' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop17;
+ }
+ } while (true);
+
+ // InternalOXtype.g:18610:40: ( ( '\\r' )? '\\n' )?
+ int alt19=2;
+ int LA19_0 = input.LA(1);
+
+ if ( (LA19_0=='\n'||LA19_0=='\r') ) {
+ alt19=1;
+ }
+ switch (alt19) {
+ case 1 :
+ // InternalOXtype.g:18610:41: ( '\\r' )? '\\n'
+ {
+ // InternalOXtype.g:18610:41: ( '\\r' )?
+ int alt18=2;
+ int LA18_0 = input.LA(1);
+
+ if ( (LA18_0=='\r') ) {
+ alt18=1;
+ }
+ switch (alt18) {
+ case 1 :
+ // InternalOXtype.g:18610:41: '\\r'
+ {
+ match('\r');
+
+ }
+ break;
+
+ }
+
+ match('\n');
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SL_COMMENT"
+
+ // $ANTLR start "RULE_WS"
+ public final void mRULE_WS() throws RecognitionException {
+ try {
+ int _type = RULE_WS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:18612:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
+ // InternalOXtype.g:18612:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+ {
+ // InternalOXtype.g:18612:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+ int cnt20=0;
+ loop20:
+ do {
+ int alt20=2;
+ int LA20_0 = input.LA(1);
+
+ if ( ((LA20_0>='\t' && LA20_0<='\n')||LA20_0=='\r'||LA20_0==' ') ) {
+ alt20=1;
+ }
+
+
+ switch (alt20) {
+ case 1 :
+ // InternalOXtype.g:
+ {
+ if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ if ( cnt20 >= 1 ) break loop20;
+ EarlyExitException eee =
+ new EarlyExitException(20, input);
+ throw eee;
+ }
+ cnt20++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_WS"
+
+ // $ANTLR start "RULE_ANY_OTHER"
+ public final void mRULE_ANY_OTHER() throws RecognitionException {
+ try {
+ int _type = RULE_ANY_OTHER;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:18614:16: ( . )
+ // InternalOXtype.g:18614:18: .
+ {
+ matchAny();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ANY_OTHER"
+
+ public void mTokens() throws RecognitionException {
+ // InternalOXtype.g:1:8: ( T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER )
+ int alt21=85;
+ alt21 = dfa21.predict(input);
+ switch (alt21) {
+ case 1 :
+ // InternalOXtype.g:1:10: T__13
+ {
+ mT__13();
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:1:16: T__14
+ {
+ mT__14();
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:1:22: T__15
+ {
+ mT__15();
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:1:28: T__16
+ {
+ mT__16();
+
+ }
+ break;
+ case 5 :
+ // InternalOXtype.g:1:34: T__17
+ {
+ mT__17();
+
+ }
+ break;
+ case 6 :
+ // InternalOXtype.g:1:40: T__18
+ {
+ mT__18();
+
+ }
+ break;
+ case 7 :
+ // InternalOXtype.g:1:46: T__19
+ {
+ mT__19();
+
+ }
+ break;
+ case 8 :
+ // InternalOXtype.g:1:52: T__20
+ {
+ mT__20();
+
+ }
+ break;
+ case 9 :
+ // InternalOXtype.g:1:58: T__21
+ {
+ mT__21();
+
+ }
+ break;
+ case 10 :
+ // InternalOXtype.g:1:64: T__22
+ {
+ mT__22();
+
+ }
+ break;
+ case 11 :
+ // InternalOXtype.g:1:70: T__23
+ {
+ mT__23();
+
+ }
+ break;
+ case 12 :
+ // InternalOXtype.g:1:76: T__24
+ {
+ mT__24();
+
+ }
+ break;
+ case 13 :
+ // InternalOXtype.g:1:82: T__25
+ {
+ mT__25();
+
+ }
+ break;
+ case 14 :
+ // InternalOXtype.g:1:88: T__26
+ {
+ mT__26();
+
+ }
+ break;
+ case 15 :
+ // InternalOXtype.g:1:94: T__27
+ {
+ mT__27();
+
+ }
+ break;
+ case 16 :
+ // InternalOXtype.g:1:100: T__28
+ {
+ mT__28();
+
+ }
+ break;
+ case 17 :
+ // InternalOXtype.g:1:106: T__29
+ {
+ mT__29();
+
+ }
+ break;
+ case 18 :
+ // InternalOXtype.g:1:112: T__30
+ {
+ mT__30();
+
+ }
+ break;
+ case 19 :
+ // InternalOXtype.g:1:118: T__31
+ {
+ mT__31();
+
+ }
+ break;
+ case 20 :
+ // InternalOXtype.g:1:124: T__32
+ {
+ mT__32();
+
+ }
+ break;
+ case 21 :
+ // InternalOXtype.g:1:130: T__33
+ {
+ mT__33();
+
+ }
+ break;
+ case 22 :
+ // InternalOXtype.g:1:136: T__34
+ {
+ mT__34();
+
+ }
+ break;
+ case 23 :
+ // InternalOXtype.g:1:142: T__35
+ {
+ mT__35();
+
+ }
+ break;
+ case 24 :
+ // InternalOXtype.g:1:148: T__36
+ {
+ mT__36();
+
+ }
+ break;
+ case 25 :
+ // InternalOXtype.g:1:154: T__37
+ {
+ mT__37();
+
+ }
+ break;
+ case 26 :
+ // InternalOXtype.g:1:160: T__38
+ {
+ mT__38();
+
+ }
+ break;
+ case 27 :
+ // InternalOXtype.g:1:166: T__39
+ {
+ mT__39();
+
+ }
+ break;
+ case 28 :
+ // InternalOXtype.g:1:172: T__40
+ {
+ mT__40();
+
+ }
+ break;
+ case 29 :
+ // InternalOXtype.g:1:178: T__41
+ {
+ mT__41();
+
+ }
+ break;
+ case 30 :
+ // InternalOXtype.g:1:184: T__42
+ {
+ mT__42();
+
+ }
+ break;
+ case 31 :
+ // InternalOXtype.g:1:190: T__43
+ {
+ mT__43();
+
+ }
+ break;
+ case 32 :
+ // InternalOXtype.g:1:196: T__44
+ {
+ mT__44();
+
+ }
+ break;
+ case 33 :
+ // InternalOXtype.g:1:202: T__45
+ {
+ mT__45();
+
+ }
+ break;
+ case 34 :
+ // InternalOXtype.g:1:208: T__46
+ {
+ mT__46();
+
+ }
+ break;
+ case 35 :
+ // InternalOXtype.g:1:214: T__47
+ {
+ mT__47();
+
+ }
+ break;
+ case 36 :
+ // InternalOXtype.g:1:220: T__48
+ {
+ mT__48();
+
+ }
+ break;
+ case 37 :
+ // InternalOXtype.g:1:226: T__49
+ {
+ mT__49();
+
+ }
+ break;
+ case 38 :
+ // InternalOXtype.g:1:232: T__50
+ {
+ mT__50();
+
+ }
+ break;
+ case 39 :
+ // InternalOXtype.g:1:238: T__51
+ {
+ mT__51();
+
+ }
+ break;
+ case 40 :
+ // InternalOXtype.g:1:244: T__52
+ {
+ mT__52();
+
+ }
+ break;
+ case 41 :
+ // InternalOXtype.g:1:250: T__53
+ {
+ mT__53();
+
+ }
+ break;
+ case 42 :
+ // InternalOXtype.g:1:256: T__54
+ {
+ mT__54();
+
+ }
+ break;
+ case 43 :
+ // InternalOXtype.g:1:262: T__55
+ {
+ mT__55();
+
+ }
+ break;
+ case 44 :
+ // InternalOXtype.g:1:268: T__56
+ {
+ mT__56();
+
+ }
+ break;
+ case 45 :
+ // InternalOXtype.g:1:274: T__57
+ {
+ mT__57();
+
+ }
+ break;
+ case 46 :
+ // InternalOXtype.g:1:280: T__58
+ {
+ mT__58();
+
+ }
+ break;
+ case 47 :
+ // InternalOXtype.g:1:286: T__59
+ {
+ mT__59();
+
+ }
+ break;
+ case 48 :
+ // InternalOXtype.g:1:292: T__60
+ {
+ mT__60();
+
+ }
+ break;
+ case 49 :
+ // InternalOXtype.g:1:298: T__61
+ {
+ mT__61();
+
+ }
+ break;
+ case 50 :
+ // InternalOXtype.g:1:304: T__62
+ {
+ mT__62();
+
+ }
+ break;
+ case 51 :
+ // InternalOXtype.g:1:310: T__63
+ {
+ mT__63();
+
+ }
+ break;
+ case 52 :
+ // InternalOXtype.g:1:316: T__64
+ {
+ mT__64();
+
+ }
+ break;
+ case 53 :
+ // InternalOXtype.g:1:322: T__65
+ {
+ mT__65();
+
+ }
+ break;
+ case 54 :
+ // InternalOXtype.g:1:328: T__66
+ {
+ mT__66();
+
+ }
+ break;
+ case 55 :
+ // InternalOXtype.g:1:334: T__67
+ {
+ mT__67();
+
+ }
+ break;
+ case 56 :
+ // InternalOXtype.g:1:340: T__68
+ {
+ mT__68();
+
+ }
+ break;
+ case 57 :
+ // InternalOXtype.g:1:346: T__69
+ {
+ mT__69();
+
+ }
+ break;
+ case 58 :
+ // InternalOXtype.g:1:352: T__70
+ {
+ mT__70();
+
+ }
+ break;
+ case 59 :
+ // InternalOXtype.g:1:358: T__71
+ {
+ mT__71();
+
+ }
+ break;
+ case 60 :
+ // InternalOXtype.g:1:364: T__72
+ {
+ mT__72();
+
+ }
+ break;
+ case 61 :
+ // InternalOXtype.g:1:370: T__73
+ {
+ mT__73();
+
+ }
+ break;
+ case 62 :
+ // InternalOXtype.g:1:376: T__74
+ {
+ mT__74();
+
+ }
+ break;
+ case 63 :
+ // InternalOXtype.g:1:382: T__75
+ {
+ mT__75();
+
+ }
+ break;
+ case 64 :
+ // InternalOXtype.g:1:388: T__76
+ {
+ mT__76();
+
+ }
+ break;
+ case 65 :
+ // InternalOXtype.g:1:394: T__77
+ {
+ mT__77();
+
+ }
+ break;
+ case 66 :
+ // InternalOXtype.g:1:400: T__78
+ {
+ mT__78();
+
+ }
+ break;
+ case 67 :
+ // InternalOXtype.g:1:406: T__79
+ {
+ mT__79();
+
+ }
+ break;
+ case 68 :
+ // InternalOXtype.g:1:412: T__80
+ {
+ mT__80();
+
+ }
+ break;
+ case 69 :
+ // InternalOXtype.g:1:418: T__81
+ {
+ mT__81();
+
+ }
+ break;
+ case 70 :
+ // InternalOXtype.g:1:424: T__82
+ {
+ mT__82();
+
+ }
+ break;
+ case 71 :
+ // InternalOXtype.g:1:430: T__83
+ {
+ mT__83();
+
+ }
+ break;
+ case 72 :
+ // InternalOXtype.g:1:436: T__84
+ {
+ mT__84();
+
+ }
+ break;
+ case 73 :
+ // InternalOXtype.g:1:442: T__85
+ {
+ mT__85();
+
+ }
+ break;
+ case 74 :
+ // InternalOXtype.g:1:448: T__86
+ {
+ mT__86();
+
+ }
+ break;
+ case 75 :
+ // InternalOXtype.g:1:454: T__87
+ {
+ mT__87();
+
+ }
+ break;
+ case 76 :
+ // InternalOXtype.g:1:460: T__88
+ {
+ mT__88();
+
+ }
+ break;
+ case 77 :
+ // InternalOXtype.g:1:466: RULE_HEX
+ {
+ mRULE_HEX();
+
+ }
+ break;
+ case 78 :
+ // InternalOXtype.g:1:475: RULE_INT
+ {
+ mRULE_INT();
+
+ }
+ break;
+ case 79 :
+ // InternalOXtype.g:1:484: RULE_DECIMAL
+ {
+ mRULE_DECIMAL();
+
+ }
+ break;
+ case 80 :
+ // InternalOXtype.g:1:497: RULE_ID
+ {
+ mRULE_ID();
+
+ }
+ break;
+ case 81 :
+ // InternalOXtype.g:1:505: RULE_STRING
+ {
+ mRULE_STRING();
+
+ }
+ break;
+ case 82 :
+ // InternalOXtype.g:1:517: RULE_ML_COMMENT
+ {
+ mRULE_ML_COMMENT();
+
+ }
+ break;
+ case 83 :
+ // InternalOXtype.g:1:533: RULE_SL_COMMENT
+ {
+ mRULE_SL_COMMENT();
+
+ }
+ break;
+ case 84 :
+ // InternalOXtype.g:1:549: RULE_WS
+ {
+ mRULE_WS();
+
+ }
+ break;
+ case 85 :
+ // InternalOXtype.g:1:557: RULE_ANY_OTHER
+ {
+ mRULE_ANY_OTHER();
+
+ }
+ break;
+
+ }
+
+ }
+
+
+ protected DFA21 dfa21 = new DFA21(this);
+ static final String DFA21_eotS =
+ "\1\uffff\1\57\1\61\1\63\1\66\1\72\1\75\1\101\1\103\1\105\1\107\1\111\1\113\1\116\5\120\10\uffff\1\120\2\uffff\1\151\6\120\2\167\1\54\5\uffff\1\174\26\uffff\1\176\5\uffff\1\u0080\4\uffff\1\120\1\uffff\10\120\1\u008b\3\120\10\uffff\1\u008f\4\uffff\1\120\1\u0091\4\120\1\u0097\4\120\1\uffff\1\167\12\uffff\1\u009d\1\u009e\10\120\1\uffff\1\120\1\u00a8\1\120\1\uffff\1\120\1\uffff\3\120\1\u00ae\1\120\1\uffff\2\120\1\u00b2\2\120\2\uffff\1\120\1\u00b6\7\120\1\uffff\2\120\1\u00c0\2\120\1\uffff\1\u00c3\2\120\1\uffff\1\u00c6\2\120\1\uffff\1\120\1\u00cb\4\120\1\u00d0\2\120\1\uffff\1\u00d3\1\u00d4\1\uffff\1\120\1\u00d6\1\uffff\3\120\1\u00da\1\uffff\1\u00db\1\120\1\u00dd\1\120\1\uffff\2\120\2\uffff\1\u00e1\1\uffff\1\u00e2\1\u00e3\1\120\2\uffff\1\120\1\uffff\1\120\1\u00e7\1\u00e8\3\uffff\3\120\2\uffff\1\u00ec\2\120\1\uffff\1\120\1\u00f0\1\120\1\uffff\1\u00f2\1\uffff";
+ static final String DFA21_eofS =
+ "\u00f3\uffff";
+ static final String DFA21_minS =
+ "\1\0\1\75\1\174\1\46\1\53\1\55\2\52\3\75\1\76\2\56\1\141\1\154\1\164\1\146\1\141\10\uffff\1\163\2\uffff\1\72\1\145\1\141\1\150\1\145\1\150\1\145\2\60\1\44\5\uffff\1\75\26\uffff\1\75\5\uffff\1\74\4\uffff\1\154\1\uffff\1\164\1\163\1\141\1\160\1\151\1\156\1\160\1\163\1\44\1\154\1\162\1\156\10\uffff\1\44\4\uffff\1\146\1\44\1\163\1\151\1\167\1\154\1\44\1\160\1\162\1\165\1\164\1\uffff\1\60\12\uffff\2\44\2\145\1\164\1\145\1\164\1\143\1\157\1\164\1\uffff\1\163\1\44\1\141\1\uffff\1\141\1\uffff\1\145\1\143\1\154\1\44\1\154\1\uffff\1\145\1\157\1\44\1\145\1\165\2\uffff\1\156\1\44\1\151\1\162\1\143\1\150\1\162\1\141\1\145\1\uffff\1\154\1\165\1\44\1\150\1\145\1\uffff\1\44\1\157\1\167\1\uffff\1\44\1\162\1\144\1\uffff\1\143\1\44\1\150\1\162\1\164\1\156\1\44\2\154\1\uffff\2\44\1\uffff\1\146\1\44\1\uffff\1\156\1\163\1\151\1\44\1\uffff\1\44\1\157\1\44\1\143\1\uffff\1\171\1\164\2\uffff\1\44\1\uffff\2\44\1\157\2\uffff\1\156\1\uffff\1\145\2\44\3\uffff\1\156\1\151\1\157\2\uffff\1\44\1\172\1\146\1\uffff\1\145\1\44\1\144\1\uffff\1\44\1\uffff";
+ static final String DFA21_maxS =
+ "\1\uffff\1\76\1\174\1\46\1\75\1\76\5\75\1\76\1\56\1\72\1\141\1\170\1\171\1\156\1\157\10\uffff\1\163\2\uffff\1\72\1\157\1\141\1\150\1\165\1\171\1\145\1\170\1\154\1\172\5\uffff\1\75\26\uffff\1\75\5\uffff\1\74\4\uffff\1\162\1\uffff\1\164\1\163\1\141\1\160\1\151\1\156\1\160\1\163\1\172\1\154\1\162\1\156\10\uffff\1\172\4\uffff\1\146\1\172\1\164\1\151\1\167\1\154\1\172\1\160\1\162\1\171\1\164\1\uffff\1\154\12\uffff\2\172\2\145\1\164\1\145\1\164\1\143\1\157\1\164\1\uffff\1\163\1\172\1\141\1\uffff\1\141\1\uffff\1\145\1\143\1\154\1\172\1\154\1\uffff\1\145\1\157\1\172\1\145\1\165\2\uffff\1\156\1\172\1\151\1\162\1\143\1\150\1\162\1\141\1\145\1\uffff\1\154\1\165\1\172\1\150\1\145\1\uffff\1\172\1\157\1\167\1\uffff\1\172\1\162\1\163\1\uffff\1\143\1\172\1\150\1\162\1\164\1\156\1\172\2\154\1\uffff\2\172\1\uffff\1\146\1\172\1\uffff\1\156\1\163\1\151\1\172\1\uffff\1\172\1\157\1\172\1\143\1\uffff\1\171\1\164\2\uffff\1\172\1\uffff\2\172\1\157\2\uffff\1\156\1\uffff\1\145\2\172\3\uffff\1\156\1\151\1\157\2\uffff\2\172\1\146\1\uffff\1\145\1\172\1\144\1\uffff\1\172\1\uffff";
+ static final String DFA21_acceptS =
+ "\23\uffff\1\47\1\50\1\51\1\52\1\53\1\54\1\55\1\56\1\uffff\1\61\1\62\12\uffff\1\120\2\121\1\124\1\125\1\uffff\1\23\1\1\1\2\1\112\1\3\1\106\1\4\1\35\1\26\1\5\1\20\1\36\1\27\1\6\1\31\1\30\1\7\1\122\1\123\1\32\1\10\1\33\1\uffff\1\34\1\15\1\16\1\24\1\17\1\uffff\1\37\1\25\1\111\1\105\1\uffff\1\120\14\uffff\1\47\1\50\1\51\1\52\1\53\1\54\1\55\1\56\1\uffff\1\61\1\62\1\110\1\66\13\uffff\1\115\1\uffff\1\116\1\117\1\121\1\124\1\13\1\11\1\14\1\12\1\21\1\22\12\uffff\1\63\3\uffff\1\60\1\uffff\1\73\5\uffff\1\107\5\uffff\1\40\1\113\11\uffff\1\71\5\uffff\1\74\3\uffff\1\101\3\uffff\1\64\11\uffff\1\70\2\uffff\1\75\2\uffff\1\114\4\uffff\1\45\4\uffff\1\46\2\uffff\1\104\1\72\1\uffff\1\77\3\uffff\1\42\1\65\1\uffff\1\43\3\uffff\1\76\1\100\1\41\3\uffff\1\102\1\67\3\uffff\1\44\3\uffff\1\57\1\uffff\1\103";
+ static final String DFA21_specialS =
+ "\1\0\u00f2\uffff}>";
+ static final String[] DFA21_transitionS = {
+ "\11\54\2\53\2\54\1\53\22\54\1\53\1\11\1\51\1\31\1\50\1\10\1\3\1\52\1\25\1\26\1\6\1\4\1\27\1\5\1\14\1\7\1\45\11\46\1\36\1\23\1\13\1\1\1\12\1\15\1\24\32\50\1\32\1\54\1\30\1\47\1\50\1\54\1\33\1\50\1\40\1\37\1\17\1\22\2\50\1\21\4\50\1\42\3\50\1\44\1\20\1\43\1\50\1\16\1\41\3\50\1\34\1\2\1\35\uff82\54",
+ "\1\55\1\56",
+ "\1\60",
+ "\1\62",
+ "\1\65\21\uffff\1\64",
+ "\1\71\17\uffff\1\67\1\70",
+ "\1\74\22\uffff\1\73",
+ "\1\77\4\uffff\1\100\15\uffff\1\76",
+ "\1\102",
+ "\1\104",
+ "\1\106",
+ "\1\110",
+ "\1\112",
+ "\1\115\13\uffff\1\114",
+ "\1\117",
+ "\1\122\13\uffff\1\121",
+ "\1\123\1\124\1\uffff\1\125\1\uffff\1\126",
+ "\1\131\6\uffff\1\127\1\130",
+ "\1\132\7\uffff\1\134\5\uffff\1\133",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\145",
+ "",
+ "",
+ "\1\150",
+ "\1\152\11\uffff\1\153",
+ "\1\154",
+ "\1\155",
+ "\1\156\15\uffff\1\160\1\uffff\1\157",
+ "\1\162\11\uffff\1\163\6\uffff\1\161",
+ "\1\164",
+ "\12\166\10\uffff\1\170\1\uffff\3\170\5\uffff\1\170\13\uffff\1\165\6\uffff\1\166\2\uffff\1\170\1\uffff\3\170\5\uffff\1\170\13\uffff\1\165",
+ "\12\166\10\uffff\1\170\1\uffff\3\170\5\uffff\1\170\22\uffff\1\166\2\uffff\1\170\1\uffff\3\170\5\uffff\1\170",
+ "\1\120\34\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\173",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\175",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\177",
+ "",
+ "",
+ "",
+ "",
+ "\1\u0081\5\uffff\1\u0082",
+ "",
+ "\1\u0083",
+ "\1\u0084",
+ "\1\u0085",
+ "\1\u0086",
+ "\1\u0087",
+ "\1\u0088",
+ "\1\u0089",
+ "\1\u008a",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u008c",
+ "\1\u008d",
+ "\1\u008e",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "",
+ "",
+ "",
+ "",
+ "\1\u0090",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u0092\1\u0093",
+ "\1\u0094",
+ "\1\u0095",
+ "\1\u0096",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u0098",
+ "\1\u0099",
+ "\1\u009b\3\uffff\1\u009a",
+ "\1\u009c",
+ "",
+ "\12\166\10\uffff\1\170\1\uffff\3\170\5\uffff\1\170\22\uffff\1\166\2\uffff\1\170\1\uffff\3\170\5\uffff\1\170",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u009f",
+ "\1\u00a0",
+ "\1\u00a1",
+ "\1\u00a2",
+ "\1\u00a3",
+ "\1\u00a4",
+ "\1\u00a5",
+ "\1\u00a6",
+ "",
+ "\1\u00a7",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u00a9",
+ "",
+ "\1\u00aa",
+ "",
+ "\1\u00ab",
+ "\1\u00ac",
+ "\1\u00ad",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u00af",
+ "",
+ "\1\u00b0",
+ "\1\u00b1",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u00b3",
+ "\1\u00b4",
+ "",
+ "",
+ "\1\u00b5",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u00b7",
+ "\1\u00b8",
+ "\1\u00b9",
+ "\1\u00ba",
+ "\1\u00bb",
+ "\1\u00bc",
+ "\1\u00bd",
+ "",
+ "\1\u00be",
+ "\1\u00bf",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u00c1",
+ "\1\u00c2",
+ "",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u00c4",
+ "\1\u00c5",
+ "",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u00c7",
+ "\1\u00c8\16\uffff\1\u00c9",
+ "",
+ "\1\u00ca",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u00cc",
+ "\1\u00cd",
+ "\1\u00ce",
+ "\1\u00cf",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u00d1",
+ "\1\u00d2",
+ "",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "",
+ "\1\u00d5",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "",
+ "\1\u00d7",
+ "\1\u00d8",
+ "\1\u00d9",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u00dc",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u00de",
+ "",
+ "\1\u00df",
+ "\1\u00e0",
+ "",
+ "",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u00e4",
+ "",
+ "",
+ "\1\u00e5",
+ "",
+ "\1\u00e6",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "",
+ "",
+ "",
+ "\1\u00e9",
+ "\1\u00ea",
+ "\1\u00eb",
+ "",
+ "",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u00ed",
+ "\1\u00ee",
+ "",
+ "\1\u00ef",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ "\1\u00f1",
+ "",
+ "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+ ""
+ };
+
+ static final short[] DFA21_eot = DFA.unpackEncodedString(DFA21_eotS);
+ static final short[] DFA21_eof = DFA.unpackEncodedString(DFA21_eofS);
+ static final char[] DFA21_min = DFA.unpackEncodedStringToUnsignedChars(DFA21_minS);
+ static final char[] DFA21_max = DFA.unpackEncodedStringToUnsignedChars(DFA21_maxS);
+ static final short[] DFA21_accept = DFA.unpackEncodedString(DFA21_acceptS);
+ static final short[] DFA21_special = DFA.unpackEncodedString(DFA21_specialS);
+ static final short[][] DFA21_transition;
+
+ static {
+ int numStates = DFA21_transitionS.length;
+ DFA21_transition = new short[numStates][];
+ for (int i=0; i<numStates; i++) {
+ DFA21_transition[i] = DFA.unpackEncodedString(DFA21_transitionS[i]);
+ }
+ }
+
+ class DFA21 extends DFA {
+
+ public DFA21(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 21;
+ this.eot = DFA21_eot;
+ this.eof = DFA21_eof;
+ this.min = DFA21_min;
+ this.max = DFA21_max;
+ this.accept = DFA21_accept;
+ this.special = DFA21_special;
+ this.transition = DFA21_transition;
+ }
+ public String getDescription() {
+ return "1:1: Tokens : ( T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER );";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ IntStream input = _input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA21_0 = input.LA(1);
+
+ s = -1;
+ if ( (LA21_0=='=') ) {s = 1;}
+
+ else if ( (LA21_0=='|') ) {s = 2;}
+
+ else if ( (LA21_0=='&') ) {s = 3;}
+
+ else if ( (LA21_0=='+') ) {s = 4;}
+
+ else if ( (LA21_0=='-') ) {s = 5;}
+
+ else if ( (LA21_0=='*') ) {s = 6;}
+
+ else if ( (LA21_0=='/') ) {s = 7;}
+
+ else if ( (LA21_0=='%') ) {s = 8;}
+
+ else if ( (LA21_0=='!') ) {s = 9;}
+
+ else if ( (LA21_0=='>') ) {s = 10;}
+
+ else if ( (LA21_0=='<') ) {s = 11;}
+
+ else if ( (LA21_0=='.') ) {s = 12;}
+
+ else if ( (LA21_0=='?') ) {s = 13;}
+
+ else if ( (LA21_0=='v') ) {s = 14;}
+
+ else if ( (LA21_0=='e') ) {s = 15;}
+
+ else if ( (LA21_0=='s') ) {s = 16;}
+
+ else if ( (LA21_0=='i') ) {s = 17;}
+
+ else if ( (LA21_0=='f') ) {s = 18;}
+
+ else if ( (LA21_0==';') ) {s = 19;}
+
+ else if ( (LA21_0=='@') ) {s = 20;}
+
+ else if ( (LA21_0=='(') ) {s = 21;}
+
+ else if ( (LA21_0==')') ) {s = 22;}
+
+ else if ( (LA21_0==',') ) {s = 23;}
+
+ else if ( (LA21_0==']') ) {s = 24;}
+
+ else if ( (LA21_0=='#') ) {s = 25;}
+
+ else if ( (LA21_0=='[') ) {s = 26;}
+
+ else if ( (LA21_0=='a') ) {s = 27;}
+
+ else if ( (LA21_0=='{') ) {s = 28;}
+
+ else if ( (LA21_0=='}') ) {s = 29;}
+
+ else if ( (LA21_0==':') ) {s = 30;}
+
+ else if ( (LA21_0=='d') ) {s = 31;}
+
+ else if ( (LA21_0=='c') ) {s = 32;}
+
+ else if ( (LA21_0=='w') ) {s = 33;}
+
+ else if ( (LA21_0=='n') ) {s = 34;}
+
+ else if ( (LA21_0=='t') ) {s = 35;}
+
+ else if ( (LA21_0=='r') ) {s = 36;}
+
+ else if ( (LA21_0=='0') ) {s = 37;}
+
+ else if ( ((LA21_0>='1' && LA21_0<='9')) ) {s = 38;}
+
+ else if ( (LA21_0=='^') ) {s = 39;}
+
+ else if ( (LA21_0=='$'||(LA21_0>='A' && LA21_0<='Z')||LA21_0=='_'||LA21_0=='b'||(LA21_0>='g' && LA21_0<='h')||(LA21_0>='j' && LA21_0<='m')||(LA21_0>='o' && LA21_0<='q')||LA21_0=='u'||(LA21_0>='x' && LA21_0<='z')) ) {s = 40;}
+
+ else if ( (LA21_0=='\"') ) {s = 41;}
+
+ else if ( (LA21_0=='\'') ) {s = 42;}
+
+ else if ( ((LA21_0>='\t' && LA21_0<='\n')||LA21_0=='\r'||LA21_0==' ') ) {s = 43;}
+
+ else if ( ((LA21_0>='\u0000' && LA21_0<='\b')||(LA21_0>='\u000B' && LA21_0<='\f')||(LA21_0>='\u000E' && LA21_0<='\u001F')||LA21_0=='\\'||LA21_0=='`'||(LA21_0>='~' && LA21_0<='\uFFFF')) ) {s = 44;}
+
+ if ( s>=0 ) return s;
+ break;
+ }
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 21, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtypeParser.java b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtypeParser.java
new file mode 100644
index 0000000..9970d8c
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtypeParser.java
@@ -0,0 +1,64524 @@
+package org.eclipse.osbp.xtext.oxtype.ide.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.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+@SuppressWarnings("all")
+public class InternalOXtypeParser extends AbstractInternalContentAssistParser {
+ public static final String[] tokenNames = new String[] {
+ "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_ID", "RULE_HEX", "RULE_INT", "RULE_DECIMAL", "RULE_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'='", "'||'", "'&&'", "'+='", "'-='", "'*='", "'/='", "'%='", "'=='", "'!='", "'==='", "'!=='", "'>='", "'>'", "'<'", "'->'", "'..<'", "'..'", "'=>'", "'<>'", "'?:'", "'+'", "'-'", "'*'", "'**'", "'/'", "'%'", "'!'", "'++'", "'--'", "'.'", "'val'", "'extends'", "'static'", "'import'", "'extension'", "'super'", "'false'", "';'", "'@'", "'('", "')'", "','", "']'", "'#'", "'['", "'instanceof'", "'as'", "'{'", "'}'", "'if'", "'else'", "'switch'", "':'", "'default'", "'case'", "'for'", "'while'", "'do'", "'new'", "'null'", "'typeof'", "'throw'", "'return'", "'try'", "'finally'", "'synchronized'", "'catch'", "'?'", "'&'", "'ns'", "'::'", "'?.'", "'|'", "'var'", "'true'"
+ };
+ public static final int RULE_HEX=5;
+ public static final int T__50=50;
+ public static final int T__19=19;
+ public static final int T__15=15;
+ public static final int T__59=59;
+ public static final int T__16=16;
+ public static final int T__17=17;
+ public static final int T__18=18;
+ public static final int T__55=55;
+ public static final int T__56=56;
+ public static final int T__13=13;
+ public static final int T__57=57;
+ public static final int T__14=14;
+ public static final int T__58=58;
+ public static final int T__51=51;
+ public static final int T__52=52;
+ public static final int T__53=53;
+ public static final int T__54=54;
+ public static final int T__60=60;
+ public static final int T__61=61;
+ public static final int RULE_ID=4;
+ public static final int RULE_DECIMAL=7;
+ public static final int T__26=26;
+ public static final int T__27=27;
+ public static final int T__28=28;
+ public static final int RULE_INT=6;
+ public static final int T__29=29;
+ public static final int T__22=22;
+ public static final int T__66=66;
+ public static final int RULE_ML_COMMENT=9;
+ public static final int T__23=23;
+ public static final int T__67=67;
+ public static final int T__24=24;
+ public static final int T__68=68;
+ public static final int T__25=25;
+ public static final int T__69=69;
+ public static final int T__62=62;
+ public static final int T__63=63;
+ public static final int T__20=20;
+ public static final int T__64=64;
+ public static final int T__21=21;
+ public static final int T__65=65;
+ public static final int T__70=70;
+ public static final int T__71=71;
+ public static final int T__72=72;
+ public static final int RULE_STRING=8;
+ public static final int RULE_SL_COMMENT=10;
+ public static final int T__37=37;
+ public static final int T__38=38;
+ public static final int T__39=39;
+ public static final int T__33=33;
+ public static final int T__77=77;
+ public static final int T__34=34;
+ public static final int T__78=78;
+ public static final int T__35=35;
+ public static final int T__79=79;
+ public static final int T__36=36;
+ public static final int T__73=73;
+ public static final int EOF=-1;
+ public static final int T__30=30;
+ public static final int T__74=74;
+ public static final int T__31=31;
+ public static final int T__75=75;
+ public static final int T__32=32;
+ public static final int T__76=76;
+ public static final int T__80=80;
+ public static final int T__81=81;
+ public static final int T__82=82;
+ public static final int T__83=83;
+ public static final int RULE_WS=11;
+ public static final int RULE_ANY_OTHER=12;
+ public static final int T__48=48;
+ public static final int T__49=49;
+ public static final int T__44=44;
+ public static final int T__88=88;
+ public static final int T__45=45;
+ public static final int T__46=46;
+ public static final int T__47=47;
+ public static final int T__40=40;
+ public static final int T__84=84;
+ public static final int T__41=41;
+ public static final int T__85=85;
+ public static final int T__42=42;
+ public static final int T__86=86;
+ public static final int T__43=43;
+ public static final int T__87=87;
+
+ // delegates
+ // delegators
+
+
+ public InternalOXtypeParser(TokenStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public InternalOXtypeParser(TokenStream input, RecognizerSharedState state) {
+ super(input, state);
+
+ }
+
+
+ public String[] getTokenNames() { return InternalOXtypeParser.tokenNames; }
+ public String getGrammarFileName() { return "InternalOXtype.g"; }
+
+
+ private OXtypeGrammarAccess grammarAccess;
+
+ public void setGrammarAccess(OXtypeGrammarAccess grammarAccess) {
+ this.grammarAccess = grammarAccess;
+ }
+
+ @Override
+ protected Grammar getGrammar() {
+ return grammarAccess.getGrammar();
+ }
+
+ @Override
+ protected String getValueForTokenName(String tokenName) {
+ return tokenName;
+ }
+
+
+
+ // $ANTLR start "entryRuleXImportDeclaration"
+ // InternalOXtype.g:54:1: entryRuleXImportDeclaration : ruleXImportDeclaration EOF ;
+ public final void entryRuleXImportDeclaration() throws RecognitionException {
+ try {
+ // InternalOXtype.g:55:1: ( ruleXImportDeclaration EOF )
+ // InternalOXtype.g:56:1: ruleXImportDeclaration EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXImportDeclaration();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXImportDeclaration"
+
+
+ // $ANTLR start "ruleXImportDeclaration"
+ // InternalOXtype.g:63:1: ruleXImportDeclaration : ( ( rule__XImportDeclaration__Group__0 ) ) ;
+ public final void ruleXImportDeclaration() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:67:2: ( ( ( rule__XImportDeclaration__Group__0 ) ) )
+ // InternalOXtype.g:68:2: ( ( rule__XImportDeclaration__Group__0 ) )
+ {
+ // InternalOXtype.g:68:2: ( ( rule__XImportDeclaration__Group__0 ) )
+ // InternalOXtype.g:69:3: ( rule__XImportDeclaration__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getGroup());
+ }
+ // InternalOXtype.g:70:3: ( rule__XImportDeclaration__Group__0 )
+ // InternalOXtype.g:70:4: rule__XImportDeclaration__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXImportDeclaration"
+
+
+ // $ANTLR start "entryRuleXAnnotation"
+ // InternalOXtype.g:79:1: entryRuleXAnnotation : ruleXAnnotation EOF ;
+ public final void entryRuleXAnnotation() throws RecognitionException {
+ try {
+ // InternalOXtype.g:80:1: ( ruleXAnnotation EOF )
+ // InternalOXtype.g:81:1: ruleXAnnotation EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXAnnotation();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXAnnotation"
+
+
+ // $ANTLR start "ruleXAnnotation"
+ // InternalOXtype.g:88:1: ruleXAnnotation : ( ( rule__XAnnotation__Group__0 ) ) ;
+ public final void ruleXAnnotation() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:92:2: ( ( ( rule__XAnnotation__Group__0 ) ) )
+ // InternalOXtype.g:93:2: ( ( rule__XAnnotation__Group__0 ) )
+ {
+ // InternalOXtype.g:93:2: ( ( rule__XAnnotation__Group__0 ) )
+ // InternalOXtype.g:94:3: ( rule__XAnnotation__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getGroup());
+ }
+ // InternalOXtype.g:95:3: ( rule__XAnnotation__Group__0 )
+ // InternalOXtype.g:95:4: rule__XAnnotation__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXAnnotation"
+
+
+ // $ANTLR start "entryRuleXAnnotationElementValuePair"
+ // InternalOXtype.g:104:1: entryRuleXAnnotationElementValuePair : ruleXAnnotationElementValuePair EOF ;
+ public final void entryRuleXAnnotationElementValuePair() throws RecognitionException {
+ try {
+ // InternalOXtype.g:105:1: ( ruleXAnnotationElementValuePair EOF )
+ // InternalOXtype.g:106:1: ruleXAnnotationElementValuePair EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValuePairRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXAnnotationElementValuePair();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValuePairRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXAnnotationElementValuePair"
+
+
+ // $ANTLR start "ruleXAnnotationElementValuePair"
+ // InternalOXtype.g:113:1: ruleXAnnotationElementValuePair : ( ( rule__XAnnotationElementValuePair__Group__0 ) ) ;
+ public final void ruleXAnnotationElementValuePair() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:117:2: ( ( ( rule__XAnnotationElementValuePair__Group__0 ) ) )
+ // InternalOXtype.g:118:2: ( ( rule__XAnnotationElementValuePair__Group__0 ) )
+ {
+ // InternalOXtype.g:118:2: ( ( rule__XAnnotationElementValuePair__Group__0 ) )
+ // InternalOXtype.g:119:3: ( rule__XAnnotationElementValuePair__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValuePairAccess().getGroup());
+ }
+ // InternalOXtype.g:120:3: ( rule__XAnnotationElementValuePair__Group__0 )
+ // InternalOXtype.g:120:4: rule__XAnnotationElementValuePair__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValuePair__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValuePairAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXAnnotationElementValuePair"
+
+
+ // $ANTLR start "entryRuleXAnnotationElementValueOrCommaList"
+ // InternalOXtype.g:129:1: entryRuleXAnnotationElementValueOrCommaList : ruleXAnnotationElementValueOrCommaList EOF ;
+ public final void entryRuleXAnnotationElementValueOrCommaList() throws RecognitionException {
+ try {
+ // InternalOXtype.g:130:1: ( ruleXAnnotationElementValueOrCommaList EOF )
+ // InternalOXtype.g:131:1: ruleXAnnotationElementValueOrCommaList EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXAnnotationElementValueOrCommaList();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXAnnotationElementValueOrCommaList"
+
+
+ // $ANTLR start "ruleXAnnotationElementValueOrCommaList"
+ // InternalOXtype.g:138:1: ruleXAnnotationElementValueOrCommaList : ( ( rule__XAnnotationElementValueOrCommaList__Alternatives ) ) ;
+ public final void ruleXAnnotationElementValueOrCommaList() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:142:2: ( ( ( rule__XAnnotationElementValueOrCommaList__Alternatives ) ) )
+ // InternalOXtype.g:143:2: ( ( rule__XAnnotationElementValueOrCommaList__Alternatives ) )
+ {
+ // InternalOXtype.g:143:2: ( ( rule__XAnnotationElementValueOrCommaList__Alternatives ) )
+ // InternalOXtype.g:144:3: ( rule__XAnnotationElementValueOrCommaList__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getAlternatives());
+ }
+ // InternalOXtype.g:145:3: ( rule__XAnnotationElementValueOrCommaList__Alternatives )
+ // InternalOXtype.g:145:4: rule__XAnnotationElementValueOrCommaList__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXAnnotationElementValueOrCommaList"
+
+
+ // $ANTLR start "entryRuleXAnnotationElementValue"
+ // InternalOXtype.g:154:1: entryRuleXAnnotationElementValue : ruleXAnnotationElementValue EOF ;
+ public final void entryRuleXAnnotationElementValue() throws RecognitionException {
+ try {
+ // InternalOXtype.g:155:1: ( ruleXAnnotationElementValue EOF )
+ // InternalOXtype.g:156:1: ruleXAnnotationElementValue EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXAnnotationElementValue();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXAnnotationElementValue"
+
+
+ // $ANTLR start "ruleXAnnotationElementValue"
+ // InternalOXtype.g:163:1: ruleXAnnotationElementValue : ( ( rule__XAnnotationElementValue__Alternatives ) ) ;
+ public final void ruleXAnnotationElementValue() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:167:2: ( ( ( rule__XAnnotationElementValue__Alternatives ) ) )
+ // InternalOXtype.g:168:2: ( ( rule__XAnnotationElementValue__Alternatives ) )
+ {
+ // InternalOXtype.g:168:2: ( ( rule__XAnnotationElementValue__Alternatives ) )
+ // InternalOXtype.g:169:3: ( rule__XAnnotationElementValue__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueAccess().getAlternatives());
+ }
+ // InternalOXtype.g:170:3: ( rule__XAnnotationElementValue__Alternatives )
+ // InternalOXtype.g:170:4: rule__XAnnotationElementValue__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXAnnotationElementValue"
+
+
+ // $ANTLR start "entryRuleXAnnotationOrExpression"
+ // InternalOXtype.g:179:1: entryRuleXAnnotationOrExpression : ruleXAnnotationOrExpression EOF ;
+ public final void entryRuleXAnnotationOrExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:180:1: ( ruleXAnnotationOrExpression EOF )
+ // InternalOXtype.g:181:1: ruleXAnnotationOrExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationOrExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXAnnotationOrExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationOrExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXAnnotationOrExpression"
+
+
+ // $ANTLR start "ruleXAnnotationOrExpression"
+ // InternalOXtype.g:188:1: ruleXAnnotationOrExpression : ( ( rule__XAnnotationOrExpression__Alternatives ) ) ;
+ public final void ruleXAnnotationOrExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:192:2: ( ( ( rule__XAnnotationOrExpression__Alternatives ) ) )
+ // InternalOXtype.g:193:2: ( ( rule__XAnnotationOrExpression__Alternatives ) )
+ {
+ // InternalOXtype.g:193:2: ( ( rule__XAnnotationOrExpression__Alternatives ) )
+ // InternalOXtype.g:194:3: ( rule__XAnnotationOrExpression__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationOrExpressionAccess().getAlternatives());
+ }
+ // InternalOXtype.g:195:3: ( rule__XAnnotationOrExpression__Alternatives )
+ // InternalOXtype.g:195:4: rule__XAnnotationOrExpression__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationOrExpression__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationOrExpressionAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXAnnotationOrExpression"
+
+
+ // $ANTLR start "entryRuleXExpression"
+ // InternalOXtype.g:204:1: entryRuleXExpression : ruleXExpression EOF ;
+ public final void entryRuleXExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:205:1: ( ruleXExpression EOF )
+ // InternalOXtype.g:206:1: ruleXExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXExpression"
+
+
+ // $ANTLR start "ruleXExpression"
+ // InternalOXtype.g:213:1: ruleXExpression : ( ruleXAssignment ) ;
+ public final void ruleXExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:217:2: ( ( ruleXAssignment ) )
+ // InternalOXtype.g:218:2: ( ruleXAssignment )
+ {
+ // InternalOXtype.g:218:2: ( ruleXAssignment )
+ // InternalOXtype.g:219:3: ruleXAssignment
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAssignment();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXExpression"
+
+
+ // $ANTLR start "entryRuleXAssignment"
+ // InternalOXtype.g:229:1: entryRuleXAssignment : ruleXAssignment EOF ;
+ public final void entryRuleXAssignment() throws RecognitionException {
+ try {
+ // InternalOXtype.g:230:1: ( ruleXAssignment EOF )
+ // InternalOXtype.g:231:1: ruleXAssignment EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXAssignment();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXAssignment"
+
+
+ // $ANTLR start "ruleXAssignment"
+ // InternalOXtype.g:238:1: ruleXAssignment : ( ( rule__XAssignment__Alternatives ) ) ;
+ public final void ruleXAssignment() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:242:2: ( ( ( rule__XAssignment__Alternatives ) ) )
+ // InternalOXtype.g:243:2: ( ( rule__XAssignment__Alternatives ) )
+ {
+ // InternalOXtype.g:243:2: ( ( rule__XAssignment__Alternatives ) )
+ // InternalOXtype.g:244:3: ( rule__XAssignment__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getAlternatives());
+ }
+ // InternalOXtype.g:245:3: ( rule__XAssignment__Alternatives )
+ // InternalOXtype.g:245:4: rule__XAssignment__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXAssignment"
+
+
+ // $ANTLR start "entryRuleOpSingleAssign"
+ // InternalOXtype.g:254:1: entryRuleOpSingleAssign : ruleOpSingleAssign EOF ;
+ public final void entryRuleOpSingleAssign() throws RecognitionException {
+ try {
+ // InternalOXtype.g:255:1: ( ruleOpSingleAssign EOF )
+ // InternalOXtype.g:256:1: ruleOpSingleAssign EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpSingleAssignRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleOpSingleAssign();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpSingleAssignRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleOpSingleAssign"
+
+
+ // $ANTLR start "ruleOpSingleAssign"
+ // InternalOXtype.g:263:1: ruleOpSingleAssign : ( '=' ) ;
+ public final void ruleOpSingleAssign() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:267:2: ( ( '=' ) )
+ // InternalOXtype.g:268:2: ( '=' )
+ {
+ // InternalOXtype.g:268:2: ( '=' )
+ // InternalOXtype.g:269:3: '='
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword());
+ }
+ match(input,13,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleOpSingleAssign"
+
+
+ // $ANTLR start "entryRuleOpMultiAssign"
+ // InternalOXtype.g:279:1: entryRuleOpMultiAssign : ruleOpMultiAssign EOF ;
+ public final void entryRuleOpMultiAssign() throws RecognitionException {
+ try {
+ // InternalOXtype.g:280:1: ( ruleOpMultiAssign EOF )
+ // InternalOXtype.g:281:1: ruleOpMultiAssign EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAssignRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleOpMultiAssign();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAssignRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleOpMultiAssign"
+
+
+ // $ANTLR start "ruleOpMultiAssign"
+ // InternalOXtype.g:288:1: ruleOpMultiAssign : ( ( rule__OpMultiAssign__Alternatives ) ) ;
+ public final void ruleOpMultiAssign() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:292:2: ( ( ( rule__OpMultiAssign__Alternatives ) ) )
+ // InternalOXtype.g:293:2: ( ( rule__OpMultiAssign__Alternatives ) )
+ {
+ // InternalOXtype.g:293:2: ( ( rule__OpMultiAssign__Alternatives ) )
+ // InternalOXtype.g:294:3: ( rule__OpMultiAssign__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAssignAccess().getAlternatives());
+ }
+ // InternalOXtype.g:295:3: ( rule__OpMultiAssign__Alternatives )
+ // InternalOXtype.g:295:4: rule__OpMultiAssign__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpMultiAssign__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAssignAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleOpMultiAssign"
+
+
+ // $ANTLR start "entryRuleXOrExpression"
+ // InternalOXtype.g:304:1: entryRuleXOrExpression : ruleXOrExpression EOF ;
+ public final void entryRuleXOrExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:305:1: ( ruleXOrExpression EOF )
+ // InternalOXtype.g:306:1: ruleXOrExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOrExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXOrExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOrExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXOrExpression"
+
+
+ // $ANTLR start "ruleXOrExpression"
+ // InternalOXtype.g:313:1: ruleXOrExpression : ( ( rule__XOrExpression__Group__0 ) ) ;
+ public final void ruleXOrExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:317:2: ( ( ( rule__XOrExpression__Group__0 ) ) )
+ // InternalOXtype.g:318:2: ( ( rule__XOrExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:318:2: ( ( rule__XOrExpression__Group__0 ) )
+ // InternalOXtype.g:319:3: ( rule__XOrExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOrExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:320:3: ( rule__XOrExpression__Group__0 )
+ // InternalOXtype.g:320:4: rule__XOrExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOrExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOrExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXOrExpression"
+
+
+ // $ANTLR start "entryRuleOpOr"
+ // InternalOXtype.g:329:1: entryRuleOpOr : ruleOpOr EOF ;
+ public final void entryRuleOpOr() throws RecognitionException {
+ try {
+ // InternalOXtype.g:330:1: ( ruleOpOr EOF )
+ // InternalOXtype.g:331:1: ruleOpOr EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOrRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleOpOr();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOrRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleOpOr"
+
+
+ // $ANTLR start "ruleOpOr"
+ // InternalOXtype.g:338:1: ruleOpOr : ( '||' ) ;
+ public final void ruleOpOr() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:342:2: ( ( '||' ) )
+ // InternalOXtype.g:343:2: ( '||' )
+ {
+ // InternalOXtype.g:343:2: ( '||' )
+ // InternalOXtype.g:344:3: '||'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword());
+ }
+ match(input,14,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleOpOr"
+
+
+ // $ANTLR start "entryRuleXAndExpression"
+ // InternalOXtype.g:354:1: entryRuleXAndExpression : ruleXAndExpression EOF ;
+ public final void entryRuleXAndExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:355:1: ( ruleXAndExpression EOF )
+ // InternalOXtype.g:356:1: ruleXAndExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAndExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXAndExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAndExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXAndExpression"
+
+
+ // $ANTLR start "ruleXAndExpression"
+ // InternalOXtype.g:363:1: ruleXAndExpression : ( ( rule__XAndExpression__Group__0 ) ) ;
+ public final void ruleXAndExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:367:2: ( ( ( rule__XAndExpression__Group__0 ) ) )
+ // InternalOXtype.g:368:2: ( ( rule__XAndExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:368:2: ( ( rule__XAndExpression__Group__0 ) )
+ // InternalOXtype.g:369:3: ( rule__XAndExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAndExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:370:3: ( rule__XAndExpression__Group__0 )
+ // InternalOXtype.g:370:4: rule__XAndExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAndExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAndExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXAndExpression"
+
+
+ // $ANTLR start "entryRuleOpAnd"
+ // InternalOXtype.g:379:1: entryRuleOpAnd : ruleOpAnd EOF ;
+ public final void entryRuleOpAnd() throws RecognitionException {
+ try {
+ // InternalOXtype.g:380:1: ( ruleOpAnd EOF )
+ // InternalOXtype.g:381:1: ruleOpAnd EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpAndRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleOpAnd();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpAndRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleOpAnd"
+
+
+ // $ANTLR start "ruleOpAnd"
+ // InternalOXtype.g:388:1: ruleOpAnd : ( '&&' ) ;
+ public final void ruleOpAnd() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:392:2: ( ( '&&' ) )
+ // InternalOXtype.g:393:2: ( '&&' )
+ {
+ // InternalOXtype.g:393:2: ( '&&' )
+ // InternalOXtype.g:394:3: '&&'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword());
+ }
+ match(input,15,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleOpAnd"
+
+
+ // $ANTLR start "entryRuleXEqualityExpression"
+ // InternalOXtype.g:404:1: entryRuleXEqualityExpression : ruleXEqualityExpression EOF ;
+ public final void entryRuleXEqualityExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:405:1: ( ruleXEqualityExpression EOF )
+ // InternalOXtype.g:406:1: ruleXEqualityExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXEqualityExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXEqualityExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXEqualityExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXEqualityExpression"
+
+
+ // $ANTLR start "ruleXEqualityExpression"
+ // InternalOXtype.g:413:1: ruleXEqualityExpression : ( ( rule__XEqualityExpression__Group__0 ) ) ;
+ public final void ruleXEqualityExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:417:2: ( ( ( rule__XEqualityExpression__Group__0 ) ) )
+ // InternalOXtype.g:418:2: ( ( rule__XEqualityExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:418:2: ( ( rule__XEqualityExpression__Group__0 ) )
+ // InternalOXtype.g:419:3: ( rule__XEqualityExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXEqualityExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:420:3: ( rule__XEqualityExpression__Group__0 )
+ // InternalOXtype.g:420:4: rule__XEqualityExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XEqualityExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXEqualityExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXEqualityExpression"
+
+
+ // $ANTLR start "entryRuleOpEquality"
+ // InternalOXtype.g:429:1: entryRuleOpEquality : ruleOpEquality EOF ;
+ public final void entryRuleOpEquality() throws RecognitionException {
+ try {
+ // InternalOXtype.g:430:1: ( ruleOpEquality EOF )
+ // InternalOXtype.g:431:1: ruleOpEquality EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpEqualityRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleOpEquality();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpEqualityRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleOpEquality"
+
+
+ // $ANTLR start "ruleOpEquality"
+ // InternalOXtype.g:438:1: ruleOpEquality : ( ( rule__OpEquality__Alternatives ) ) ;
+ public final void ruleOpEquality() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:442:2: ( ( ( rule__OpEquality__Alternatives ) ) )
+ // InternalOXtype.g:443:2: ( ( rule__OpEquality__Alternatives ) )
+ {
+ // InternalOXtype.g:443:2: ( ( rule__OpEquality__Alternatives ) )
+ // InternalOXtype.g:444:3: ( rule__OpEquality__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpEqualityAccess().getAlternatives());
+ }
+ // InternalOXtype.g:445:3: ( rule__OpEquality__Alternatives )
+ // InternalOXtype.g:445:4: rule__OpEquality__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpEquality__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpEqualityAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleOpEquality"
+
+
+ // $ANTLR start "entryRuleXRelationalExpression"
+ // InternalOXtype.g:454:1: entryRuleXRelationalExpression : ruleXRelationalExpression EOF ;
+ public final void entryRuleXRelationalExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:455:1: ( ruleXRelationalExpression EOF )
+ // InternalOXtype.g:456:1: ruleXRelationalExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXRelationalExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXRelationalExpression"
+
+
+ // $ANTLR start "ruleXRelationalExpression"
+ // InternalOXtype.g:463:1: ruleXRelationalExpression : ( ( rule__XRelationalExpression__Group__0 ) ) ;
+ public final void ruleXRelationalExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:467:2: ( ( ( rule__XRelationalExpression__Group__0 ) ) )
+ // InternalOXtype.g:468:2: ( ( rule__XRelationalExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:468:2: ( ( rule__XRelationalExpression__Group__0 ) )
+ // InternalOXtype.g:469:3: ( rule__XRelationalExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:470:3: ( rule__XRelationalExpression__Group__0 )
+ // InternalOXtype.g:470:4: rule__XRelationalExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXRelationalExpression"
+
+
+ // $ANTLR start "entryRuleOpCompare"
+ // InternalOXtype.g:479:1: entryRuleOpCompare : ruleOpCompare EOF ;
+ public final void entryRuleOpCompare() throws RecognitionException {
+ try {
+ // InternalOXtype.g:480:1: ( ruleOpCompare EOF )
+ // InternalOXtype.g:481:1: ruleOpCompare EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpCompareRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleOpCompare();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpCompareRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleOpCompare"
+
+
+ // $ANTLR start "ruleOpCompare"
+ // InternalOXtype.g:488:1: ruleOpCompare : ( ( rule__OpCompare__Alternatives ) ) ;
+ public final void ruleOpCompare() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:492:2: ( ( ( rule__OpCompare__Alternatives ) ) )
+ // InternalOXtype.g:493:2: ( ( rule__OpCompare__Alternatives ) )
+ {
+ // InternalOXtype.g:493:2: ( ( rule__OpCompare__Alternatives ) )
+ // InternalOXtype.g:494:3: ( rule__OpCompare__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpCompareAccess().getAlternatives());
+ }
+ // InternalOXtype.g:495:3: ( rule__OpCompare__Alternatives )
+ // InternalOXtype.g:495:4: rule__OpCompare__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpCompare__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpCompareAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleOpCompare"
+
+
+ // $ANTLR start "entryRuleXOtherOperatorExpression"
+ // InternalOXtype.g:504:1: entryRuleXOtherOperatorExpression : ruleXOtherOperatorExpression EOF ;
+ public final void entryRuleXOtherOperatorExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:505:1: ( ruleXOtherOperatorExpression EOF )
+ // InternalOXtype.g:506:1: ruleXOtherOperatorExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOtherOperatorExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXOtherOperatorExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOtherOperatorExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXOtherOperatorExpression"
+
+
+ // $ANTLR start "ruleXOtherOperatorExpression"
+ // InternalOXtype.g:513:1: ruleXOtherOperatorExpression : ( ( rule__XOtherOperatorExpression__Group__0 ) ) ;
+ public final void ruleXOtherOperatorExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:517:2: ( ( ( rule__XOtherOperatorExpression__Group__0 ) ) )
+ // InternalOXtype.g:518:2: ( ( rule__XOtherOperatorExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:518:2: ( ( rule__XOtherOperatorExpression__Group__0 ) )
+ // InternalOXtype.g:519:3: ( rule__XOtherOperatorExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:520:3: ( rule__XOtherOperatorExpression__Group__0 )
+ // InternalOXtype.g:520:4: rule__XOtherOperatorExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOtherOperatorExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXOtherOperatorExpression"
+
+
+ // $ANTLR start "entryRuleOpOther"
+ // InternalOXtype.g:529:1: entryRuleOpOther : ruleOpOther EOF ;
+ public final void entryRuleOpOther() throws RecognitionException {
+ try {
+ // InternalOXtype.g:530:1: ( ruleOpOther EOF )
+ // InternalOXtype.g:531:1: ruleOpOther EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleOpOther();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleOpOther"
+
+
+ // $ANTLR start "ruleOpOther"
+ // InternalOXtype.g:538:1: ruleOpOther : ( ( rule__OpOther__Alternatives ) ) ;
+ public final void ruleOpOther() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:542:2: ( ( ( rule__OpOther__Alternatives ) ) )
+ // InternalOXtype.g:543:2: ( ( rule__OpOther__Alternatives ) )
+ {
+ // InternalOXtype.g:543:2: ( ( rule__OpOther__Alternatives ) )
+ // InternalOXtype.g:544:3: ( rule__OpOther__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getAlternatives());
+ }
+ // InternalOXtype.g:545:3: ( rule__OpOther__Alternatives )
+ // InternalOXtype.g:545:4: rule__OpOther__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleOpOther"
+
+
+ // $ANTLR start "entryRuleXAdditiveExpression"
+ // InternalOXtype.g:554:1: entryRuleXAdditiveExpression : ruleXAdditiveExpression EOF ;
+ public final void entryRuleXAdditiveExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:555:1: ( ruleXAdditiveExpression EOF )
+ // InternalOXtype.g:556:1: ruleXAdditiveExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAdditiveExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXAdditiveExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAdditiveExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXAdditiveExpression"
+
+
+ // $ANTLR start "ruleXAdditiveExpression"
+ // InternalOXtype.g:563:1: ruleXAdditiveExpression : ( ( rule__XAdditiveExpression__Group__0 ) ) ;
+ public final void ruleXAdditiveExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:567:2: ( ( ( rule__XAdditiveExpression__Group__0 ) ) )
+ // InternalOXtype.g:568:2: ( ( rule__XAdditiveExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:568:2: ( ( rule__XAdditiveExpression__Group__0 ) )
+ // InternalOXtype.g:569:3: ( rule__XAdditiveExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAdditiveExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:570:3: ( rule__XAdditiveExpression__Group__0 )
+ // InternalOXtype.g:570:4: rule__XAdditiveExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAdditiveExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAdditiveExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXAdditiveExpression"
+
+
+ // $ANTLR start "entryRuleOpAdd"
+ // InternalOXtype.g:579:1: entryRuleOpAdd : ruleOpAdd EOF ;
+ public final void entryRuleOpAdd() throws RecognitionException {
+ try {
+ // InternalOXtype.g:580:1: ( ruleOpAdd EOF )
+ // InternalOXtype.g:581:1: ruleOpAdd EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpAddRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleOpAdd();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpAddRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleOpAdd"
+
+
+ // $ANTLR start "ruleOpAdd"
+ // InternalOXtype.g:588:1: ruleOpAdd : ( ( rule__OpAdd__Alternatives ) ) ;
+ public final void ruleOpAdd() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:592:2: ( ( ( rule__OpAdd__Alternatives ) ) )
+ // InternalOXtype.g:593:2: ( ( rule__OpAdd__Alternatives ) )
+ {
+ // InternalOXtype.g:593:2: ( ( rule__OpAdd__Alternatives ) )
+ // InternalOXtype.g:594:3: ( rule__OpAdd__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpAddAccess().getAlternatives());
+ }
+ // InternalOXtype.g:595:3: ( rule__OpAdd__Alternatives )
+ // InternalOXtype.g:595:4: rule__OpAdd__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpAdd__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpAddAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleOpAdd"
+
+
+ // $ANTLR start "entryRuleXMultiplicativeExpression"
+ // InternalOXtype.g:604:1: entryRuleXMultiplicativeExpression : ruleXMultiplicativeExpression EOF ;
+ public final void entryRuleXMultiplicativeExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:605:1: ( ruleXMultiplicativeExpression EOF )
+ // InternalOXtype.g:606:1: ruleXMultiplicativeExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMultiplicativeExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXMultiplicativeExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMultiplicativeExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXMultiplicativeExpression"
+
+
+ // $ANTLR start "ruleXMultiplicativeExpression"
+ // InternalOXtype.g:613:1: ruleXMultiplicativeExpression : ( ( rule__XMultiplicativeExpression__Group__0 ) ) ;
+ public final void ruleXMultiplicativeExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:617:2: ( ( ( rule__XMultiplicativeExpression__Group__0 ) ) )
+ // InternalOXtype.g:618:2: ( ( rule__XMultiplicativeExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:618:2: ( ( rule__XMultiplicativeExpression__Group__0 ) )
+ // InternalOXtype.g:619:3: ( rule__XMultiplicativeExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:620:3: ( rule__XMultiplicativeExpression__Group__0 )
+ // InternalOXtype.g:620:4: rule__XMultiplicativeExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMultiplicativeExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXMultiplicativeExpression"
+
+
+ // $ANTLR start "entryRuleOpMulti"
+ // InternalOXtype.g:629:1: entryRuleOpMulti : ruleOpMulti EOF ;
+ public final void entryRuleOpMulti() throws RecognitionException {
+ try {
+ // InternalOXtype.g:630:1: ( ruleOpMulti EOF )
+ // InternalOXtype.g:631:1: ruleOpMulti EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleOpMulti();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleOpMulti"
+
+
+ // $ANTLR start "ruleOpMulti"
+ // InternalOXtype.g:638:1: ruleOpMulti : ( ( rule__OpMulti__Alternatives ) ) ;
+ public final void ruleOpMulti() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:642:2: ( ( ( rule__OpMulti__Alternatives ) ) )
+ // InternalOXtype.g:643:2: ( ( rule__OpMulti__Alternatives ) )
+ {
+ // InternalOXtype.g:643:2: ( ( rule__OpMulti__Alternatives ) )
+ // InternalOXtype.g:644:3: ( rule__OpMulti__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAccess().getAlternatives());
+ }
+ // InternalOXtype.g:645:3: ( rule__OpMulti__Alternatives )
+ // InternalOXtype.g:645:4: rule__OpMulti__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpMulti__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleOpMulti"
+
+
+ // $ANTLR start "entryRuleXUnaryOperation"
+ // InternalOXtype.g:654:1: entryRuleXUnaryOperation : ruleXUnaryOperation EOF ;
+ public final void entryRuleXUnaryOperation() throws RecognitionException {
+ try {
+ // InternalOXtype.g:655:1: ( ruleXUnaryOperation EOF )
+ // InternalOXtype.g:656:1: ruleXUnaryOperation EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXUnaryOperationRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXUnaryOperation();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXUnaryOperationRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXUnaryOperation"
+
+
+ // $ANTLR start "ruleXUnaryOperation"
+ // InternalOXtype.g:663:1: ruleXUnaryOperation : ( ( rule__XUnaryOperation__Alternatives ) ) ;
+ public final void ruleXUnaryOperation() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:667:2: ( ( ( rule__XUnaryOperation__Alternatives ) ) )
+ // InternalOXtype.g:668:2: ( ( rule__XUnaryOperation__Alternatives ) )
+ {
+ // InternalOXtype.g:668:2: ( ( rule__XUnaryOperation__Alternatives ) )
+ // InternalOXtype.g:669:3: ( rule__XUnaryOperation__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXUnaryOperationAccess().getAlternatives());
+ }
+ // InternalOXtype.g:670:3: ( rule__XUnaryOperation__Alternatives )
+ // InternalOXtype.g:670:4: rule__XUnaryOperation__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__XUnaryOperation__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXUnaryOperationAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXUnaryOperation"
+
+
+ // $ANTLR start "entryRuleOpUnary"
+ // InternalOXtype.g:679:1: entryRuleOpUnary : ruleOpUnary EOF ;
+ public final void entryRuleOpUnary() throws RecognitionException {
+ try {
+ // InternalOXtype.g:680:1: ( ruleOpUnary EOF )
+ // InternalOXtype.g:681:1: ruleOpUnary EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpUnaryRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleOpUnary();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpUnaryRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleOpUnary"
+
+
+ // $ANTLR start "ruleOpUnary"
+ // InternalOXtype.g:688:1: ruleOpUnary : ( ( rule__OpUnary__Alternatives ) ) ;
+ public final void ruleOpUnary() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:692:2: ( ( ( rule__OpUnary__Alternatives ) ) )
+ // InternalOXtype.g:693:2: ( ( rule__OpUnary__Alternatives ) )
+ {
+ // InternalOXtype.g:693:2: ( ( rule__OpUnary__Alternatives ) )
+ // InternalOXtype.g:694:3: ( rule__OpUnary__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpUnaryAccess().getAlternatives());
+ }
+ // InternalOXtype.g:695:3: ( rule__OpUnary__Alternatives )
+ // InternalOXtype.g:695:4: rule__OpUnary__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpUnary__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpUnaryAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleOpUnary"
+
+
+ // $ANTLR start "entryRuleXCastedExpression"
+ // InternalOXtype.g:704:1: entryRuleXCastedExpression : ruleXCastedExpression EOF ;
+ public final void entryRuleXCastedExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:705:1: ( ruleXCastedExpression EOF )
+ // InternalOXtype.g:706:1: ruleXCastedExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCastedExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXCastedExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCastedExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXCastedExpression"
+
+
+ // $ANTLR start "ruleXCastedExpression"
+ // InternalOXtype.g:713:1: ruleXCastedExpression : ( ( rule__XCastedExpression__Group__0 ) ) ;
+ public final void ruleXCastedExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:717:2: ( ( ( rule__XCastedExpression__Group__0 ) ) )
+ // InternalOXtype.g:718:2: ( ( rule__XCastedExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:718:2: ( ( rule__XCastedExpression__Group__0 ) )
+ // InternalOXtype.g:719:3: ( rule__XCastedExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCastedExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:720:3: ( rule__XCastedExpression__Group__0 )
+ // InternalOXtype.g:720:4: rule__XCastedExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCastedExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCastedExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXCastedExpression"
+
+
+ // $ANTLR start "entryRuleXPostfixOperation"
+ // InternalOXtype.g:729:1: entryRuleXPostfixOperation : ruleXPostfixOperation EOF ;
+ public final void entryRuleXPostfixOperation() throws RecognitionException {
+ try {
+ // InternalOXtype.g:730:1: ( ruleXPostfixOperation EOF )
+ // InternalOXtype.g:731:1: ruleXPostfixOperation EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPostfixOperationRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXPostfixOperation();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPostfixOperationRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXPostfixOperation"
+
+
+ // $ANTLR start "ruleXPostfixOperation"
+ // InternalOXtype.g:738:1: ruleXPostfixOperation : ( ( rule__XPostfixOperation__Group__0 ) ) ;
+ public final void ruleXPostfixOperation() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:742:2: ( ( ( rule__XPostfixOperation__Group__0 ) ) )
+ // InternalOXtype.g:743:2: ( ( rule__XPostfixOperation__Group__0 ) )
+ {
+ // InternalOXtype.g:743:2: ( ( rule__XPostfixOperation__Group__0 ) )
+ // InternalOXtype.g:744:3: ( rule__XPostfixOperation__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPostfixOperationAccess().getGroup());
+ }
+ // InternalOXtype.g:745:3: ( rule__XPostfixOperation__Group__0 )
+ // InternalOXtype.g:745:4: rule__XPostfixOperation__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XPostfixOperation__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPostfixOperationAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXPostfixOperation"
+
+
+ // $ANTLR start "entryRuleOpPostfix"
+ // InternalOXtype.g:754:1: entryRuleOpPostfix : ruleOpPostfix EOF ;
+ public final void entryRuleOpPostfix() throws RecognitionException {
+ try {
+ // InternalOXtype.g:755:1: ( ruleOpPostfix EOF )
+ // InternalOXtype.g:756:1: ruleOpPostfix EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpPostfixRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleOpPostfix();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpPostfixRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleOpPostfix"
+
+
+ // $ANTLR start "ruleOpPostfix"
+ // InternalOXtype.g:763:1: ruleOpPostfix : ( ( rule__OpPostfix__Alternatives ) ) ;
+ public final void ruleOpPostfix() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:767:2: ( ( ( rule__OpPostfix__Alternatives ) ) )
+ // InternalOXtype.g:768:2: ( ( rule__OpPostfix__Alternatives ) )
+ {
+ // InternalOXtype.g:768:2: ( ( rule__OpPostfix__Alternatives ) )
+ // InternalOXtype.g:769:3: ( rule__OpPostfix__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpPostfixAccess().getAlternatives());
+ }
+ // InternalOXtype.g:770:3: ( rule__OpPostfix__Alternatives )
+ // InternalOXtype.g:770:4: rule__OpPostfix__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpPostfix__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpPostfixAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleOpPostfix"
+
+
+ // $ANTLR start "entryRuleXMemberFeatureCall"
+ // InternalOXtype.g:779:1: entryRuleXMemberFeatureCall : ruleXMemberFeatureCall EOF ;
+ public final void entryRuleXMemberFeatureCall() throws RecognitionException {
+ try {
+ // InternalOXtype.g:780:1: ( ruleXMemberFeatureCall EOF )
+ // InternalOXtype.g:781:1: ruleXMemberFeatureCall EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXMemberFeatureCall();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXMemberFeatureCall"
+
+
+ // $ANTLR start "ruleXMemberFeatureCall"
+ // InternalOXtype.g:788:1: ruleXMemberFeatureCall : ( ( rule__XMemberFeatureCall__Group__0 ) ) ;
+ public final void ruleXMemberFeatureCall() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:792:2: ( ( ( rule__XMemberFeatureCall__Group__0 ) ) )
+ // InternalOXtype.g:793:2: ( ( rule__XMemberFeatureCall__Group__0 ) )
+ {
+ // InternalOXtype.g:793:2: ( ( rule__XMemberFeatureCall__Group__0 ) )
+ // InternalOXtype.g:794:3: ( rule__XMemberFeatureCall__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getGroup());
+ }
+ // InternalOXtype.g:795:3: ( rule__XMemberFeatureCall__Group__0 )
+ // InternalOXtype.g:795:4: rule__XMemberFeatureCall__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXMemberFeatureCall"
+
+
+ // $ANTLR start "entryRuleXPrimaryExpression"
+ // InternalOXtype.g:804:1: entryRuleXPrimaryExpression : ruleXPrimaryExpression EOF ;
+ public final void entryRuleXPrimaryExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:805:1: ( ruleXPrimaryExpression EOF )
+ // InternalOXtype.g:806:1: ruleXPrimaryExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXPrimaryExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPrimaryExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXPrimaryExpression"
+
+
+ // $ANTLR start "ruleXPrimaryExpression"
+ // InternalOXtype.g:813:1: ruleXPrimaryExpression : ( ( rule__XPrimaryExpression__Alternatives ) ) ;
+ public final void ruleXPrimaryExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:817:2: ( ( ( rule__XPrimaryExpression__Alternatives ) ) )
+ // InternalOXtype.g:818:2: ( ( rule__XPrimaryExpression__Alternatives ) )
+ {
+ // InternalOXtype.g:818:2: ( ( rule__XPrimaryExpression__Alternatives ) )
+ // InternalOXtype.g:819:3: ( rule__XPrimaryExpression__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getAlternatives());
+ }
+ // InternalOXtype.g:820:3: ( rule__XPrimaryExpression__Alternatives )
+ // InternalOXtype.g:820:4: rule__XPrimaryExpression__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__XPrimaryExpression__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPrimaryExpressionAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXPrimaryExpression"
+
+
+ // $ANTLR start "entryRuleXLiteral"
+ // InternalOXtype.g:829:1: entryRuleXLiteral : ruleXLiteral EOF ;
+ public final void entryRuleXLiteral() throws RecognitionException {
+ try {
+ // InternalOXtype.g:830:1: ( ruleXLiteral EOF )
+ // InternalOXtype.g:831:1: ruleXLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXLiteralRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXLiteral"
+
+
+ // $ANTLR start "ruleXLiteral"
+ // InternalOXtype.g:838:1: ruleXLiteral : ( ( rule__XLiteral__Alternatives ) ) ;
+ public final void ruleXLiteral() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:842:2: ( ( ( rule__XLiteral__Alternatives ) ) )
+ // InternalOXtype.g:843:2: ( ( rule__XLiteral__Alternatives ) )
+ {
+ // InternalOXtype.g:843:2: ( ( rule__XLiteral__Alternatives ) )
+ // InternalOXtype.g:844:3: ( rule__XLiteral__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXLiteralAccess().getAlternatives());
+ }
+ // InternalOXtype.g:845:3: ( rule__XLiteral__Alternatives )
+ // InternalOXtype.g:845:4: rule__XLiteral__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__XLiteral__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXLiteralAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXLiteral"
+
+
+ // $ANTLR start "entryRuleXCollectionLiteral"
+ // InternalOXtype.g:854:1: entryRuleXCollectionLiteral : ruleXCollectionLiteral EOF ;
+ public final void entryRuleXCollectionLiteral() throws RecognitionException {
+ try {
+ // InternalOXtype.g:855:1: ( ruleXCollectionLiteral EOF )
+ // InternalOXtype.g:856:1: ruleXCollectionLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCollectionLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXCollectionLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCollectionLiteralRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXCollectionLiteral"
+
+
+ // $ANTLR start "ruleXCollectionLiteral"
+ // InternalOXtype.g:863:1: ruleXCollectionLiteral : ( ( rule__XCollectionLiteral__Alternatives ) ) ;
+ public final void ruleXCollectionLiteral() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:867:2: ( ( ( rule__XCollectionLiteral__Alternatives ) ) )
+ // InternalOXtype.g:868:2: ( ( rule__XCollectionLiteral__Alternatives ) )
+ {
+ // InternalOXtype.g:868:2: ( ( rule__XCollectionLiteral__Alternatives ) )
+ // InternalOXtype.g:869:3: ( rule__XCollectionLiteral__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCollectionLiteralAccess().getAlternatives());
+ }
+ // InternalOXtype.g:870:3: ( rule__XCollectionLiteral__Alternatives )
+ // InternalOXtype.g:870:4: rule__XCollectionLiteral__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCollectionLiteral__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCollectionLiteralAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXCollectionLiteral"
+
+
+ // $ANTLR start "entryRuleXSetLiteral"
+ // InternalOXtype.g:879:1: entryRuleXSetLiteral : ruleXSetLiteral EOF ;
+ public final void entryRuleXSetLiteral() throws RecognitionException {
+ try {
+ // InternalOXtype.g:880:1: ( ruleXSetLiteral EOF )
+ // InternalOXtype.g:881:1: ruleXSetLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSetLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXSetLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSetLiteralRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXSetLiteral"
+
+
+ // $ANTLR start "ruleXSetLiteral"
+ // InternalOXtype.g:888:1: ruleXSetLiteral : ( ( rule__XSetLiteral__Group__0 ) ) ;
+ public final void ruleXSetLiteral() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:892:2: ( ( ( rule__XSetLiteral__Group__0 ) ) )
+ // InternalOXtype.g:893:2: ( ( rule__XSetLiteral__Group__0 ) )
+ {
+ // InternalOXtype.g:893:2: ( ( rule__XSetLiteral__Group__0 ) )
+ // InternalOXtype.g:894:3: ( rule__XSetLiteral__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSetLiteralAccess().getGroup());
+ }
+ // InternalOXtype.g:895:3: ( rule__XSetLiteral__Group__0 )
+ // InternalOXtype.g:895:4: rule__XSetLiteral__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSetLiteral__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSetLiteralAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXSetLiteral"
+
+
+ // $ANTLR start "entryRuleXListLiteral"
+ // InternalOXtype.g:904:1: entryRuleXListLiteral : ruleXListLiteral EOF ;
+ public final void entryRuleXListLiteral() throws RecognitionException {
+ try {
+ // InternalOXtype.g:905:1: ( ruleXListLiteral EOF )
+ // InternalOXtype.g:906:1: ruleXListLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXListLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXListLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXListLiteralRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXListLiteral"
+
+
+ // $ANTLR start "ruleXListLiteral"
+ // InternalOXtype.g:913:1: ruleXListLiteral : ( ( rule__XListLiteral__Group__0 ) ) ;
+ public final void ruleXListLiteral() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:917:2: ( ( ( rule__XListLiteral__Group__0 ) ) )
+ // InternalOXtype.g:918:2: ( ( rule__XListLiteral__Group__0 ) )
+ {
+ // InternalOXtype.g:918:2: ( ( rule__XListLiteral__Group__0 ) )
+ // InternalOXtype.g:919:3: ( rule__XListLiteral__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXListLiteralAccess().getGroup());
+ }
+ // InternalOXtype.g:920:3: ( rule__XListLiteral__Group__0 )
+ // InternalOXtype.g:920:4: rule__XListLiteral__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XListLiteral__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXListLiteralAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXListLiteral"
+
+
+ // $ANTLR start "entryRuleXClosure"
+ // InternalOXtype.g:929:1: entryRuleXClosure : ruleXClosure EOF ;
+ public final void entryRuleXClosure() throws RecognitionException {
+ try {
+ // InternalOXtype.g:930:1: ( ruleXClosure EOF )
+ // InternalOXtype.g:931:1: ruleXClosure EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXClosure();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXClosure"
+
+
+ // $ANTLR start "ruleXClosure"
+ // InternalOXtype.g:938:1: ruleXClosure : ( ( rule__XClosure__Group__0 ) ) ;
+ public final void ruleXClosure() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:942:2: ( ( ( rule__XClosure__Group__0 ) ) )
+ // InternalOXtype.g:943:2: ( ( rule__XClosure__Group__0 ) )
+ {
+ // InternalOXtype.g:943:2: ( ( rule__XClosure__Group__0 ) )
+ // InternalOXtype.g:944:3: ( rule__XClosure__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getGroup());
+ }
+ // InternalOXtype.g:945:3: ( rule__XClosure__Group__0 )
+ // InternalOXtype.g:945:4: rule__XClosure__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXClosure"
+
+
+ // $ANTLR start "entryRuleXExpressionInClosure"
+ // InternalOXtype.g:954:1: entryRuleXExpressionInClosure : ruleXExpressionInClosure EOF ;
+ public final void entryRuleXExpressionInClosure() throws RecognitionException {
+ try {
+ // InternalOXtype.g:955:1: ( ruleXExpressionInClosure EOF )
+ // InternalOXtype.g:956:1: ruleXExpressionInClosure EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXExpressionInClosureRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXExpressionInClosure();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXExpressionInClosureRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXExpressionInClosure"
+
+
+ // $ANTLR start "ruleXExpressionInClosure"
+ // InternalOXtype.g:963:1: ruleXExpressionInClosure : ( ( rule__XExpressionInClosure__Group__0 ) ) ;
+ public final void ruleXExpressionInClosure() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:967:2: ( ( ( rule__XExpressionInClosure__Group__0 ) ) )
+ // InternalOXtype.g:968:2: ( ( rule__XExpressionInClosure__Group__0 ) )
+ {
+ // InternalOXtype.g:968:2: ( ( rule__XExpressionInClosure__Group__0 ) )
+ // InternalOXtype.g:969:3: ( rule__XExpressionInClosure__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXExpressionInClosureAccess().getGroup());
+ }
+ // InternalOXtype.g:970:3: ( rule__XExpressionInClosure__Group__0 )
+ // InternalOXtype.g:970:4: rule__XExpressionInClosure__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XExpressionInClosure__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXExpressionInClosureAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXExpressionInClosure"
+
+
+ // $ANTLR start "entryRuleXShortClosure"
+ // InternalOXtype.g:979:1: entryRuleXShortClosure : ruleXShortClosure EOF ;
+ public final void entryRuleXShortClosure() throws RecognitionException {
+ try {
+ // InternalOXtype.g:980:1: ( ruleXShortClosure EOF )
+ // InternalOXtype.g:981:1: ruleXShortClosure EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXShortClosureRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXShortClosure();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXShortClosureRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXShortClosure"
+
+
+ // $ANTLR start "ruleXShortClosure"
+ // InternalOXtype.g:988:1: ruleXShortClosure : ( ( rule__XShortClosure__Group__0 ) ) ;
+ public final void ruleXShortClosure() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:992:2: ( ( ( rule__XShortClosure__Group__0 ) ) )
+ // InternalOXtype.g:993:2: ( ( rule__XShortClosure__Group__0 ) )
+ {
+ // InternalOXtype.g:993:2: ( ( rule__XShortClosure__Group__0 ) )
+ // InternalOXtype.g:994:3: ( rule__XShortClosure__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXShortClosureAccess().getGroup());
+ }
+ // InternalOXtype.g:995:3: ( rule__XShortClosure__Group__0 )
+ // InternalOXtype.g:995:4: rule__XShortClosure__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXShortClosureAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXShortClosure"
+
+
+ // $ANTLR start "entryRuleXParenthesizedExpression"
+ // InternalOXtype.g:1004:1: entryRuleXParenthesizedExpression : ruleXParenthesizedExpression EOF ;
+ public final void entryRuleXParenthesizedExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1005:1: ( ruleXParenthesizedExpression EOF )
+ // InternalOXtype.g:1006:1: ruleXParenthesizedExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXParenthesizedExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXParenthesizedExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXParenthesizedExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXParenthesizedExpression"
+
+
+ // $ANTLR start "ruleXParenthesizedExpression"
+ // InternalOXtype.g:1013:1: ruleXParenthesizedExpression : ( ( rule__XParenthesizedExpression__Group__0 ) ) ;
+ public final void ruleXParenthesizedExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1017:2: ( ( ( rule__XParenthesizedExpression__Group__0 ) ) )
+ // InternalOXtype.g:1018:2: ( ( rule__XParenthesizedExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:1018:2: ( ( rule__XParenthesizedExpression__Group__0 ) )
+ // InternalOXtype.g:1019:3: ( rule__XParenthesizedExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXParenthesizedExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:1020:3: ( rule__XParenthesizedExpression__Group__0 )
+ // InternalOXtype.g:1020:4: rule__XParenthesizedExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XParenthesizedExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXParenthesizedExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXParenthesizedExpression"
+
+
+ // $ANTLR start "entryRuleXIfExpression"
+ // InternalOXtype.g:1029:1: entryRuleXIfExpression : ruleXIfExpression EOF ;
+ public final void entryRuleXIfExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1030:1: ( ruleXIfExpression EOF )
+ // InternalOXtype.g:1031:1: ruleXIfExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXIfExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXIfExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXIfExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXIfExpression"
+
+
+ // $ANTLR start "ruleXIfExpression"
+ // InternalOXtype.g:1038:1: ruleXIfExpression : ( ( rule__XIfExpression__Group__0 ) ) ;
+ public final void ruleXIfExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1042:2: ( ( ( rule__XIfExpression__Group__0 ) ) )
+ // InternalOXtype.g:1043:2: ( ( rule__XIfExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:1043:2: ( ( rule__XIfExpression__Group__0 ) )
+ // InternalOXtype.g:1044:3: ( rule__XIfExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXIfExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:1045:3: ( rule__XIfExpression__Group__0 )
+ // InternalOXtype.g:1045:4: rule__XIfExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XIfExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXIfExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXIfExpression"
+
+
+ // $ANTLR start "entryRuleXSwitchExpression"
+ // InternalOXtype.g:1054:1: entryRuleXSwitchExpression : ruleXSwitchExpression EOF ;
+ public final void entryRuleXSwitchExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1055:1: ( ruleXSwitchExpression EOF )
+ // InternalOXtype.g:1056:1: ruleXSwitchExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXSwitchExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXSwitchExpression"
+
+
+ // $ANTLR start "ruleXSwitchExpression"
+ // InternalOXtype.g:1063:1: ruleXSwitchExpression : ( ( rule__XSwitchExpression__Group__0 ) ) ;
+ public final void ruleXSwitchExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1067:2: ( ( ( rule__XSwitchExpression__Group__0 ) ) )
+ // InternalOXtype.g:1068:2: ( ( rule__XSwitchExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:1068:2: ( ( rule__XSwitchExpression__Group__0 ) )
+ // InternalOXtype.g:1069:3: ( rule__XSwitchExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:1070:3: ( rule__XSwitchExpression__Group__0 )
+ // InternalOXtype.g:1070:4: rule__XSwitchExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXSwitchExpression"
+
+
+ // $ANTLR start "entryRuleXCasePart"
+ // InternalOXtype.g:1079:1: entryRuleXCasePart : ruleXCasePart EOF ;
+ public final void entryRuleXCasePart() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1080:1: ( ruleXCasePart EOF )
+ // InternalOXtype.g:1081:1: ruleXCasePart EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCasePartRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXCasePart();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCasePartRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXCasePart"
+
+
+ // $ANTLR start "ruleXCasePart"
+ // InternalOXtype.g:1088:1: ruleXCasePart : ( ( rule__XCasePart__Group__0 ) ) ;
+ public final void ruleXCasePart() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1092:2: ( ( ( rule__XCasePart__Group__0 ) ) )
+ // InternalOXtype.g:1093:2: ( ( rule__XCasePart__Group__0 ) )
+ {
+ // InternalOXtype.g:1093:2: ( ( rule__XCasePart__Group__0 ) )
+ // InternalOXtype.g:1094:3: ( rule__XCasePart__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCasePartAccess().getGroup());
+ }
+ // InternalOXtype.g:1095:3: ( rule__XCasePart__Group__0 )
+ // InternalOXtype.g:1095:4: rule__XCasePart__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCasePart__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCasePartAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXCasePart"
+
+
+ // $ANTLR start "entryRuleXForLoopExpression"
+ // InternalOXtype.g:1104:1: entryRuleXForLoopExpression : ruleXForLoopExpression EOF ;
+ public final void entryRuleXForLoopExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1105:1: ( ruleXForLoopExpression EOF )
+ // InternalOXtype.g:1106:1: ruleXForLoopExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXForLoopExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXForLoopExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXForLoopExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXForLoopExpression"
+
+
+ // $ANTLR start "ruleXForLoopExpression"
+ // InternalOXtype.g:1113:1: ruleXForLoopExpression : ( ( rule__XForLoopExpression__Group__0 ) ) ;
+ public final void ruleXForLoopExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1117:2: ( ( ( rule__XForLoopExpression__Group__0 ) ) )
+ // InternalOXtype.g:1118:2: ( ( rule__XForLoopExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:1118:2: ( ( rule__XForLoopExpression__Group__0 ) )
+ // InternalOXtype.g:1119:3: ( rule__XForLoopExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXForLoopExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:1120:3: ( rule__XForLoopExpression__Group__0 )
+ // InternalOXtype.g:1120:4: rule__XForLoopExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XForLoopExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXForLoopExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXForLoopExpression"
+
+
+ // $ANTLR start "entryRuleXBasicForLoopExpression"
+ // InternalOXtype.g:1129:1: entryRuleXBasicForLoopExpression : ruleXBasicForLoopExpression EOF ;
+ public final void entryRuleXBasicForLoopExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1130:1: ( ruleXBasicForLoopExpression EOF )
+ // InternalOXtype.g:1131:1: ruleXBasicForLoopExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXBasicForLoopExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXBasicForLoopExpression"
+
+
+ // $ANTLR start "ruleXBasicForLoopExpression"
+ // InternalOXtype.g:1138:1: ruleXBasicForLoopExpression : ( ( rule__XBasicForLoopExpression__Group__0 ) ) ;
+ public final void ruleXBasicForLoopExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1142:2: ( ( ( rule__XBasicForLoopExpression__Group__0 ) ) )
+ // InternalOXtype.g:1143:2: ( ( rule__XBasicForLoopExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:1143:2: ( ( rule__XBasicForLoopExpression__Group__0 ) )
+ // InternalOXtype.g:1144:3: ( rule__XBasicForLoopExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:1145:3: ( rule__XBasicForLoopExpression__Group__0 )
+ // InternalOXtype.g:1145:4: rule__XBasicForLoopExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXBasicForLoopExpression"
+
+
+ // $ANTLR start "entryRuleXWhileExpression"
+ // InternalOXtype.g:1154:1: entryRuleXWhileExpression : ruleXWhileExpression EOF ;
+ public final void entryRuleXWhileExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1155:1: ( ruleXWhileExpression EOF )
+ // InternalOXtype.g:1156:1: ruleXWhileExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXWhileExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXWhileExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXWhileExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXWhileExpression"
+
+
+ // $ANTLR start "ruleXWhileExpression"
+ // InternalOXtype.g:1163:1: ruleXWhileExpression : ( ( rule__XWhileExpression__Group__0 ) ) ;
+ public final void ruleXWhileExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1167:2: ( ( ( rule__XWhileExpression__Group__0 ) ) )
+ // InternalOXtype.g:1168:2: ( ( rule__XWhileExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:1168:2: ( ( rule__XWhileExpression__Group__0 ) )
+ // InternalOXtype.g:1169:3: ( rule__XWhileExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXWhileExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:1170:3: ( rule__XWhileExpression__Group__0 )
+ // InternalOXtype.g:1170:4: rule__XWhileExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XWhileExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXWhileExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXWhileExpression"
+
+
+ // $ANTLR start "entryRuleXDoWhileExpression"
+ // InternalOXtype.g:1179:1: entryRuleXDoWhileExpression : ruleXDoWhileExpression EOF ;
+ public final void entryRuleXDoWhileExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1180:1: ( ruleXDoWhileExpression EOF )
+ // InternalOXtype.g:1181:1: ruleXDoWhileExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXDoWhileExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXDoWhileExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXDoWhileExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXDoWhileExpression"
+
+
+ // $ANTLR start "ruleXDoWhileExpression"
+ // InternalOXtype.g:1188:1: ruleXDoWhileExpression : ( ( rule__XDoWhileExpression__Group__0 ) ) ;
+ public final void ruleXDoWhileExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1192:2: ( ( ( rule__XDoWhileExpression__Group__0 ) ) )
+ // InternalOXtype.g:1193:2: ( ( rule__XDoWhileExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:1193:2: ( ( rule__XDoWhileExpression__Group__0 ) )
+ // InternalOXtype.g:1194:3: ( rule__XDoWhileExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXDoWhileExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:1195:3: ( rule__XDoWhileExpression__Group__0 )
+ // InternalOXtype.g:1195:4: rule__XDoWhileExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XDoWhileExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXDoWhileExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXDoWhileExpression"
+
+
+ // $ANTLR start "entryRuleXBlockExpression"
+ // InternalOXtype.g:1204:1: entryRuleXBlockExpression : ruleXBlockExpression EOF ;
+ public final void entryRuleXBlockExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1205:1: ( ruleXBlockExpression EOF )
+ // InternalOXtype.g:1206:1: ruleXBlockExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBlockExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXBlockExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBlockExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXBlockExpression"
+
+
+ // $ANTLR start "ruleXBlockExpression"
+ // InternalOXtype.g:1213:1: ruleXBlockExpression : ( ( rule__XBlockExpression__Group__0 ) ) ;
+ public final void ruleXBlockExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1217:2: ( ( ( rule__XBlockExpression__Group__0 ) ) )
+ // InternalOXtype.g:1218:2: ( ( rule__XBlockExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:1218:2: ( ( rule__XBlockExpression__Group__0 ) )
+ // InternalOXtype.g:1219:3: ( rule__XBlockExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBlockExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:1220:3: ( rule__XBlockExpression__Group__0 )
+ // InternalOXtype.g:1220:4: rule__XBlockExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBlockExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBlockExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXBlockExpression"
+
+
+ // $ANTLR start "entryRuleXExpressionOrVarDeclaration"
+ // InternalOXtype.g:1229:1: entryRuleXExpressionOrVarDeclaration : ruleXExpressionOrVarDeclaration EOF ;
+ public final void entryRuleXExpressionOrVarDeclaration() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1230:1: ( ruleXExpressionOrVarDeclaration EOF )
+ // InternalOXtype.g:1231:1: ruleXExpressionOrVarDeclaration EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXExpressionOrVarDeclarationRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXExpressionOrVarDeclaration();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXExpressionOrVarDeclarationRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXExpressionOrVarDeclaration"
+
+
+ // $ANTLR start "ruleXExpressionOrVarDeclaration"
+ // InternalOXtype.g:1238:1: ruleXExpressionOrVarDeclaration : ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) ;
+ public final void ruleXExpressionOrVarDeclaration() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1242:2: ( ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) )
+ // InternalOXtype.g:1243:2: ( ( rule__XExpressionOrVarDeclaration__Alternatives ) )
+ {
+ // InternalOXtype.g:1243:2: ( ( rule__XExpressionOrVarDeclaration__Alternatives ) )
+ // InternalOXtype.g:1244:3: ( rule__XExpressionOrVarDeclaration__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives());
+ }
+ // InternalOXtype.g:1245:3: ( rule__XExpressionOrVarDeclaration__Alternatives )
+ // InternalOXtype.g:1245:4: rule__XExpressionOrVarDeclaration__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__XExpressionOrVarDeclaration__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXExpressionOrVarDeclaration"
+
+
+ // $ANTLR start "entryRuleXVariableDeclaration"
+ // InternalOXtype.g:1254:1: entryRuleXVariableDeclaration : ruleXVariableDeclaration EOF ;
+ public final void entryRuleXVariableDeclaration() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1255:1: ( ruleXVariableDeclaration EOF )
+ // InternalOXtype.g:1256:1: ruleXVariableDeclaration EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXVariableDeclaration();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXVariableDeclaration"
+
+
+ // $ANTLR start "ruleXVariableDeclaration"
+ // InternalOXtype.g:1263:1: ruleXVariableDeclaration : ( ( rule__XVariableDeclaration__Group__0 ) ) ;
+ public final void ruleXVariableDeclaration() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1267:2: ( ( ( rule__XVariableDeclaration__Group__0 ) ) )
+ // InternalOXtype.g:1268:2: ( ( rule__XVariableDeclaration__Group__0 ) )
+ {
+ // InternalOXtype.g:1268:2: ( ( rule__XVariableDeclaration__Group__0 ) )
+ // InternalOXtype.g:1269:3: ( rule__XVariableDeclaration__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getGroup());
+ }
+ // InternalOXtype.g:1270:3: ( rule__XVariableDeclaration__Group__0 )
+ // InternalOXtype.g:1270:4: rule__XVariableDeclaration__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXVariableDeclaration"
+
+
+ // $ANTLR start "entryRuleJvmFormalParameter"
+ // InternalOXtype.g:1279:1: entryRuleJvmFormalParameter : ruleJvmFormalParameter EOF ;
+ public final void entryRuleJvmFormalParameter() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1280:1: ( ruleJvmFormalParameter EOF )
+ // InternalOXtype.g:1281:1: ruleJvmFormalParameter EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmFormalParameterRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmFormalParameterRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleJvmFormalParameter"
+
+
+ // $ANTLR start "ruleJvmFormalParameter"
+ // InternalOXtype.g:1288:1: ruleJvmFormalParameter : ( ( rule__JvmFormalParameter__Group__0 ) ) ;
+ public final void ruleJvmFormalParameter() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1292:2: ( ( ( rule__JvmFormalParameter__Group__0 ) ) )
+ // InternalOXtype.g:1293:2: ( ( rule__JvmFormalParameter__Group__0 ) )
+ {
+ // InternalOXtype.g:1293:2: ( ( rule__JvmFormalParameter__Group__0 ) )
+ // InternalOXtype.g:1294:3: ( rule__JvmFormalParameter__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmFormalParameterAccess().getGroup());
+ }
+ // InternalOXtype.g:1295:3: ( rule__JvmFormalParameter__Group__0 )
+ // InternalOXtype.g:1295:4: rule__JvmFormalParameter__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmFormalParameter__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmFormalParameterAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleJvmFormalParameter"
+
+
+ // $ANTLR start "entryRuleFullJvmFormalParameter"
+ // InternalOXtype.g:1304:1: entryRuleFullJvmFormalParameter : ruleFullJvmFormalParameter EOF ;
+ public final void entryRuleFullJvmFormalParameter() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1305:1: ( ruleFullJvmFormalParameter EOF )
+ // InternalOXtype.g:1306:1: ruleFullJvmFormalParameter EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFullJvmFormalParameterRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleFullJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFullJvmFormalParameterRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleFullJvmFormalParameter"
+
+
+ // $ANTLR start "ruleFullJvmFormalParameter"
+ // InternalOXtype.g:1313:1: ruleFullJvmFormalParameter : ( ( rule__FullJvmFormalParameter__Group__0 ) ) ;
+ public final void ruleFullJvmFormalParameter() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1317:2: ( ( ( rule__FullJvmFormalParameter__Group__0 ) ) )
+ // InternalOXtype.g:1318:2: ( ( rule__FullJvmFormalParameter__Group__0 ) )
+ {
+ // InternalOXtype.g:1318:2: ( ( rule__FullJvmFormalParameter__Group__0 ) )
+ // InternalOXtype.g:1319:3: ( rule__FullJvmFormalParameter__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFullJvmFormalParameterAccess().getGroup());
+ }
+ // InternalOXtype.g:1320:3: ( rule__FullJvmFormalParameter__Group__0 )
+ // InternalOXtype.g:1320:4: rule__FullJvmFormalParameter__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__FullJvmFormalParameter__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFullJvmFormalParameterAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleFullJvmFormalParameter"
+
+
+ // $ANTLR start "entryRuleXFeatureCall"
+ // InternalOXtype.g:1329:1: entryRuleXFeatureCall : ruleXFeatureCall EOF ;
+ public final void entryRuleXFeatureCall() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1330:1: ( ruleXFeatureCall EOF )
+ // InternalOXtype.g:1331:1: ruleXFeatureCall EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXFeatureCall();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXFeatureCall"
+
+
+ // $ANTLR start "ruleXFeatureCall"
+ // InternalOXtype.g:1338:1: ruleXFeatureCall : ( ( rule__XFeatureCall__Group__0 ) ) ;
+ public final void ruleXFeatureCall() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1342:2: ( ( ( rule__XFeatureCall__Group__0 ) ) )
+ // InternalOXtype.g:1343:2: ( ( rule__XFeatureCall__Group__0 ) )
+ {
+ // InternalOXtype.g:1343:2: ( ( rule__XFeatureCall__Group__0 ) )
+ // InternalOXtype.g:1344:3: ( rule__XFeatureCall__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getGroup());
+ }
+ // InternalOXtype.g:1345:3: ( rule__XFeatureCall__Group__0 )
+ // InternalOXtype.g:1345:4: rule__XFeatureCall__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXFeatureCall"
+
+
+ // $ANTLR start "entryRuleFeatureCallID"
+ // InternalOXtype.g:1354:1: entryRuleFeatureCallID : ruleFeatureCallID EOF ;
+ public final void entryRuleFeatureCallID() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1355:1: ( ruleFeatureCallID EOF )
+ // InternalOXtype.g:1356:1: ruleFeatureCallID EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFeatureCallIDRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleFeatureCallID();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFeatureCallIDRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleFeatureCallID"
+
+
+ // $ANTLR start "ruleFeatureCallID"
+ // InternalOXtype.g:1363:1: ruleFeatureCallID : ( ( rule__FeatureCallID__Alternatives ) ) ;
+ public final void ruleFeatureCallID() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1367:2: ( ( ( rule__FeatureCallID__Alternatives ) ) )
+ // InternalOXtype.g:1368:2: ( ( rule__FeatureCallID__Alternatives ) )
+ {
+ // InternalOXtype.g:1368:2: ( ( rule__FeatureCallID__Alternatives ) )
+ // InternalOXtype.g:1369:3: ( rule__FeatureCallID__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFeatureCallIDAccess().getAlternatives());
+ }
+ // InternalOXtype.g:1370:3: ( rule__FeatureCallID__Alternatives )
+ // InternalOXtype.g:1370:4: rule__FeatureCallID__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__FeatureCallID__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFeatureCallIDAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleFeatureCallID"
+
+
+ // $ANTLR start "entryRuleIdOrSuper"
+ // InternalOXtype.g:1379:1: entryRuleIdOrSuper : ruleIdOrSuper EOF ;
+ public final void entryRuleIdOrSuper() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1380:1: ( ruleIdOrSuper EOF )
+ // InternalOXtype.g:1381:1: ruleIdOrSuper EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIdOrSuperRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleIdOrSuper();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIdOrSuperRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleIdOrSuper"
+
+
+ // $ANTLR start "ruleIdOrSuper"
+ // InternalOXtype.g:1388:1: ruleIdOrSuper : ( ( rule__IdOrSuper__Alternatives ) ) ;
+ public final void ruleIdOrSuper() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1392:2: ( ( ( rule__IdOrSuper__Alternatives ) ) )
+ // InternalOXtype.g:1393:2: ( ( rule__IdOrSuper__Alternatives ) )
+ {
+ // InternalOXtype.g:1393:2: ( ( rule__IdOrSuper__Alternatives ) )
+ // InternalOXtype.g:1394:3: ( rule__IdOrSuper__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIdOrSuperAccess().getAlternatives());
+ }
+ // InternalOXtype.g:1395:3: ( rule__IdOrSuper__Alternatives )
+ // InternalOXtype.g:1395:4: rule__IdOrSuper__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__IdOrSuper__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIdOrSuperAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleIdOrSuper"
+
+
+ // $ANTLR start "entryRuleXConstructorCall"
+ // InternalOXtype.g:1404:1: entryRuleXConstructorCall : ruleXConstructorCall EOF ;
+ public final void entryRuleXConstructorCall() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1405:1: ( ruleXConstructorCall EOF )
+ // InternalOXtype.g:1406:1: ruleXConstructorCall EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXConstructorCall();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXConstructorCall"
+
+
+ // $ANTLR start "ruleXConstructorCall"
+ // InternalOXtype.g:1413:1: ruleXConstructorCall : ( ( rule__XConstructorCall__Group__0 ) ) ;
+ public final void ruleXConstructorCall() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1417:2: ( ( ( rule__XConstructorCall__Group__0 ) ) )
+ // InternalOXtype.g:1418:2: ( ( rule__XConstructorCall__Group__0 ) )
+ {
+ // InternalOXtype.g:1418:2: ( ( rule__XConstructorCall__Group__0 ) )
+ // InternalOXtype.g:1419:3: ( rule__XConstructorCall__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getGroup());
+ }
+ // InternalOXtype.g:1420:3: ( rule__XConstructorCall__Group__0 )
+ // InternalOXtype.g:1420:4: rule__XConstructorCall__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXConstructorCall"
+
+
+ // $ANTLR start "entryRuleXBooleanLiteral"
+ // InternalOXtype.g:1429:1: entryRuleXBooleanLiteral : ruleXBooleanLiteral EOF ;
+ public final void entryRuleXBooleanLiteral() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1430:1: ( ruleXBooleanLiteral EOF )
+ // InternalOXtype.g:1431:1: ruleXBooleanLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBooleanLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXBooleanLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBooleanLiteralRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXBooleanLiteral"
+
+
+ // $ANTLR start "ruleXBooleanLiteral"
+ // InternalOXtype.g:1438:1: ruleXBooleanLiteral : ( ( rule__XBooleanLiteral__Group__0 ) ) ;
+ public final void ruleXBooleanLiteral() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1442:2: ( ( ( rule__XBooleanLiteral__Group__0 ) ) )
+ // InternalOXtype.g:1443:2: ( ( rule__XBooleanLiteral__Group__0 ) )
+ {
+ // InternalOXtype.g:1443:2: ( ( rule__XBooleanLiteral__Group__0 ) )
+ // InternalOXtype.g:1444:3: ( rule__XBooleanLiteral__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBooleanLiteralAccess().getGroup());
+ }
+ // InternalOXtype.g:1445:3: ( rule__XBooleanLiteral__Group__0 )
+ // InternalOXtype.g:1445:4: rule__XBooleanLiteral__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBooleanLiteral__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBooleanLiteralAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXBooleanLiteral"
+
+
+ // $ANTLR start "entryRuleXNullLiteral"
+ // InternalOXtype.g:1454:1: entryRuleXNullLiteral : ruleXNullLiteral EOF ;
+ public final void entryRuleXNullLiteral() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1455:1: ( ruleXNullLiteral EOF )
+ // InternalOXtype.g:1456:1: ruleXNullLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXNullLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXNullLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXNullLiteralRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXNullLiteral"
+
+
+ // $ANTLR start "ruleXNullLiteral"
+ // InternalOXtype.g:1463:1: ruleXNullLiteral : ( ( rule__XNullLiteral__Group__0 ) ) ;
+ public final void ruleXNullLiteral() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1467:2: ( ( ( rule__XNullLiteral__Group__0 ) ) )
+ // InternalOXtype.g:1468:2: ( ( rule__XNullLiteral__Group__0 ) )
+ {
+ // InternalOXtype.g:1468:2: ( ( rule__XNullLiteral__Group__0 ) )
+ // InternalOXtype.g:1469:3: ( rule__XNullLiteral__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXNullLiteralAccess().getGroup());
+ }
+ // InternalOXtype.g:1470:3: ( rule__XNullLiteral__Group__0 )
+ // InternalOXtype.g:1470:4: rule__XNullLiteral__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XNullLiteral__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXNullLiteralAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXNullLiteral"
+
+
+ // $ANTLR start "entryRuleXNumberLiteral"
+ // InternalOXtype.g:1479:1: entryRuleXNumberLiteral : ruleXNumberLiteral EOF ;
+ public final void entryRuleXNumberLiteral() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1480:1: ( ruleXNumberLiteral EOF )
+ // InternalOXtype.g:1481:1: ruleXNumberLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXNumberLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXNumberLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXNumberLiteralRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXNumberLiteral"
+
+
+ // $ANTLR start "ruleXNumberLiteral"
+ // InternalOXtype.g:1488:1: ruleXNumberLiteral : ( ( rule__XNumberLiteral__Group__0 ) ) ;
+ public final void ruleXNumberLiteral() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1492:2: ( ( ( rule__XNumberLiteral__Group__0 ) ) )
+ // InternalOXtype.g:1493:2: ( ( rule__XNumberLiteral__Group__0 ) )
+ {
+ // InternalOXtype.g:1493:2: ( ( rule__XNumberLiteral__Group__0 ) )
+ // InternalOXtype.g:1494:3: ( rule__XNumberLiteral__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXNumberLiteralAccess().getGroup());
+ }
+ // InternalOXtype.g:1495:3: ( rule__XNumberLiteral__Group__0 )
+ // InternalOXtype.g:1495:4: rule__XNumberLiteral__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XNumberLiteral__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXNumberLiteralAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXNumberLiteral"
+
+
+ // $ANTLR start "entryRuleXStringLiteral"
+ // InternalOXtype.g:1504:1: entryRuleXStringLiteral : ruleXStringLiteral EOF ;
+ public final void entryRuleXStringLiteral() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1505:1: ( ruleXStringLiteral EOF )
+ // InternalOXtype.g:1506:1: ruleXStringLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXStringLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXStringLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXStringLiteralRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXStringLiteral"
+
+
+ // $ANTLR start "ruleXStringLiteral"
+ // InternalOXtype.g:1513:1: ruleXStringLiteral : ( ( rule__XStringLiteral__Group__0 ) ) ;
+ public final void ruleXStringLiteral() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1517:2: ( ( ( rule__XStringLiteral__Group__0 ) ) )
+ // InternalOXtype.g:1518:2: ( ( rule__XStringLiteral__Group__0 ) )
+ {
+ // InternalOXtype.g:1518:2: ( ( rule__XStringLiteral__Group__0 ) )
+ // InternalOXtype.g:1519:3: ( rule__XStringLiteral__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXStringLiteralAccess().getGroup());
+ }
+ // InternalOXtype.g:1520:3: ( rule__XStringLiteral__Group__0 )
+ // InternalOXtype.g:1520:4: rule__XStringLiteral__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XStringLiteral__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXStringLiteralAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXStringLiteral"
+
+
+ // $ANTLR start "entryRuleXTypeLiteral"
+ // InternalOXtype.g:1529:1: entryRuleXTypeLiteral : ruleXTypeLiteral EOF ;
+ public final void entryRuleXTypeLiteral() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1530:1: ( ruleXTypeLiteral EOF )
+ // InternalOXtype.g:1531:1: ruleXTypeLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTypeLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXTypeLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTypeLiteralRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXTypeLiteral"
+
+
+ // $ANTLR start "ruleXTypeLiteral"
+ // InternalOXtype.g:1538:1: ruleXTypeLiteral : ( ( rule__XTypeLiteral__Group__0 ) ) ;
+ public final void ruleXTypeLiteral() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1542:2: ( ( ( rule__XTypeLiteral__Group__0 ) ) )
+ // InternalOXtype.g:1543:2: ( ( rule__XTypeLiteral__Group__0 ) )
+ {
+ // InternalOXtype.g:1543:2: ( ( rule__XTypeLiteral__Group__0 ) )
+ // InternalOXtype.g:1544:3: ( rule__XTypeLiteral__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTypeLiteralAccess().getGroup());
+ }
+ // InternalOXtype.g:1545:3: ( rule__XTypeLiteral__Group__0 )
+ // InternalOXtype.g:1545:4: rule__XTypeLiteral__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XTypeLiteral__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTypeLiteralAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXTypeLiteral"
+
+
+ // $ANTLR start "entryRuleXThrowExpression"
+ // InternalOXtype.g:1554:1: entryRuleXThrowExpression : ruleXThrowExpression EOF ;
+ public final void entryRuleXThrowExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1555:1: ( ruleXThrowExpression EOF )
+ // InternalOXtype.g:1556:1: ruleXThrowExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXThrowExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXThrowExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXThrowExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXThrowExpression"
+
+
+ // $ANTLR start "ruleXThrowExpression"
+ // InternalOXtype.g:1563:1: ruleXThrowExpression : ( ( rule__XThrowExpression__Group__0 ) ) ;
+ public final void ruleXThrowExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1567:2: ( ( ( rule__XThrowExpression__Group__0 ) ) )
+ // InternalOXtype.g:1568:2: ( ( rule__XThrowExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:1568:2: ( ( rule__XThrowExpression__Group__0 ) )
+ // InternalOXtype.g:1569:3: ( rule__XThrowExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXThrowExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:1570:3: ( rule__XThrowExpression__Group__0 )
+ // InternalOXtype.g:1570:4: rule__XThrowExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XThrowExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXThrowExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXThrowExpression"
+
+
+ // $ANTLR start "entryRuleXReturnExpression"
+ // InternalOXtype.g:1579:1: entryRuleXReturnExpression : ruleXReturnExpression EOF ;
+ public final void entryRuleXReturnExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1580:1: ( ruleXReturnExpression EOF )
+ // InternalOXtype.g:1581:1: ruleXReturnExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXReturnExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXReturnExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXReturnExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXReturnExpression"
+
+
+ // $ANTLR start "ruleXReturnExpression"
+ // InternalOXtype.g:1588:1: ruleXReturnExpression : ( ( rule__XReturnExpression__Group__0 ) ) ;
+ public final void ruleXReturnExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1592:2: ( ( ( rule__XReturnExpression__Group__0 ) ) )
+ // InternalOXtype.g:1593:2: ( ( rule__XReturnExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:1593:2: ( ( rule__XReturnExpression__Group__0 ) )
+ // InternalOXtype.g:1594:3: ( rule__XReturnExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXReturnExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:1595:3: ( rule__XReturnExpression__Group__0 )
+ // InternalOXtype.g:1595:4: rule__XReturnExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XReturnExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXReturnExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXReturnExpression"
+
+
+ // $ANTLR start "entryRuleXTryCatchFinallyExpression"
+ // InternalOXtype.g:1604:1: entryRuleXTryCatchFinallyExpression : ruleXTryCatchFinallyExpression EOF ;
+ public final void entryRuleXTryCatchFinallyExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1605:1: ( ruleXTryCatchFinallyExpression EOF )
+ // InternalOXtype.g:1606:1: ruleXTryCatchFinallyExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXTryCatchFinallyExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXTryCatchFinallyExpression"
+
+
+ // $ANTLR start "ruleXTryCatchFinallyExpression"
+ // InternalOXtype.g:1613:1: ruleXTryCatchFinallyExpression : ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) ;
+ public final void ruleXTryCatchFinallyExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1617:2: ( ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) )
+ // InternalOXtype.g:1618:2: ( ( rule__XTryCatchFinallyExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:1618:2: ( ( rule__XTryCatchFinallyExpression__Group__0 ) )
+ // InternalOXtype.g:1619:3: ( rule__XTryCatchFinallyExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:1620:3: ( rule__XTryCatchFinallyExpression__Group__0 )
+ // InternalOXtype.g:1620:4: rule__XTryCatchFinallyExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXTryCatchFinallyExpression"
+
+
+ // $ANTLR start "entryRuleXSynchronizedExpression"
+ // InternalOXtype.g:1629:1: entryRuleXSynchronizedExpression : ruleXSynchronizedExpression EOF ;
+ public final void entryRuleXSynchronizedExpression() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1630:1: ( ruleXSynchronizedExpression EOF )
+ // InternalOXtype.g:1631:1: ruleXSynchronizedExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSynchronizedExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXSynchronizedExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSynchronizedExpressionRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXSynchronizedExpression"
+
+
+ // $ANTLR start "ruleXSynchronizedExpression"
+ // InternalOXtype.g:1638:1: ruleXSynchronizedExpression : ( ( rule__XSynchronizedExpression__Group__0 ) ) ;
+ public final void ruleXSynchronizedExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1642:2: ( ( ( rule__XSynchronizedExpression__Group__0 ) ) )
+ // InternalOXtype.g:1643:2: ( ( rule__XSynchronizedExpression__Group__0 ) )
+ {
+ // InternalOXtype.g:1643:2: ( ( rule__XSynchronizedExpression__Group__0 ) )
+ // InternalOXtype.g:1644:3: ( rule__XSynchronizedExpression__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSynchronizedExpressionAccess().getGroup());
+ }
+ // InternalOXtype.g:1645:3: ( rule__XSynchronizedExpression__Group__0 )
+ // InternalOXtype.g:1645:4: rule__XSynchronizedExpression__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSynchronizedExpression__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSynchronizedExpressionAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXSynchronizedExpression"
+
+
+ // $ANTLR start "entryRuleXCatchClause"
+ // InternalOXtype.g:1654:1: entryRuleXCatchClause : ruleXCatchClause EOF ;
+ public final void entryRuleXCatchClause() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1655:1: ( ruleXCatchClause EOF )
+ // InternalOXtype.g:1656:1: ruleXCatchClause EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCatchClauseRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXCatchClause();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCatchClauseRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXCatchClause"
+
+
+ // $ANTLR start "ruleXCatchClause"
+ // InternalOXtype.g:1663:1: ruleXCatchClause : ( ( rule__XCatchClause__Group__0 ) ) ;
+ public final void ruleXCatchClause() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1667:2: ( ( ( rule__XCatchClause__Group__0 ) ) )
+ // InternalOXtype.g:1668:2: ( ( rule__XCatchClause__Group__0 ) )
+ {
+ // InternalOXtype.g:1668:2: ( ( rule__XCatchClause__Group__0 ) )
+ // InternalOXtype.g:1669:3: ( rule__XCatchClause__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCatchClauseAccess().getGroup());
+ }
+ // InternalOXtype.g:1670:3: ( rule__XCatchClause__Group__0 )
+ // InternalOXtype.g:1670:4: rule__XCatchClause__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCatchClause__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCatchClauseAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXCatchClause"
+
+
+ // $ANTLR start "entryRuleQualifiedName"
+ // InternalOXtype.g:1679:1: entryRuleQualifiedName : ruleQualifiedName EOF ;
+ public final void entryRuleQualifiedName() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1680:1: ( ruleQualifiedName EOF )
+ // InternalOXtype.g:1681:1: ruleQualifiedName EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getQualifiedNameRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleQualifiedName();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getQualifiedNameRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleQualifiedName"
+
+
+ // $ANTLR start "ruleQualifiedName"
+ // InternalOXtype.g:1688:1: ruleQualifiedName : ( ( rule__QualifiedName__Group__0 ) ) ;
+ public final void ruleQualifiedName() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1692:2: ( ( ( rule__QualifiedName__Group__0 ) ) )
+ // InternalOXtype.g:1693:2: ( ( rule__QualifiedName__Group__0 ) )
+ {
+ // InternalOXtype.g:1693:2: ( ( rule__QualifiedName__Group__0 ) )
+ // InternalOXtype.g:1694:3: ( rule__QualifiedName__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getQualifiedNameAccess().getGroup());
+ }
+ // InternalOXtype.g:1695:3: ( rule__QualifiedName__Group__0 )
+ // InternalOXtype.g:1695:4: rule__QualifiedName__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__QualifiedName__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getQualifiedNameAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleQualifiedName"
+
+
+ // $ANTLR start "entryRuleNumber"
+ // InternalOXtype.g:1704:1: entryRuleNumber : ruleNumber EOF ;
+ public final void entryRuleNumber() throws RecognitionException {
+
+ HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+
+ try {
+ // InternalOXtype.g:1708:1: ( ruleNumber EOF )
+ // InternalOXtype.g:1709:1: ruleNumber EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNumberRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleNumber();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNumberRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ myHiddenTokenState.restore();
+
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleNumber"
+
+
+ // $ANTLR start "ruleNumber"
+ // InternalOXtype.g:1719:1: ruleNumber : ( ( rule__Number__Alternatives ) ) ;
+ public final void ruleNumber() throws RecognitionException {
+
+ HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1724:2: ( ( ( rule__Number__Alternatives ) ) )
+ // InternalOXtype.g:1725:2: ( ( rule__Number__Alternatives ) )
+ {
+ // InternalOXtype.g:1725:2: ( ( rule__Number__Alternatives ) )
+ // InternalOXtype.g:1726:3: ( rule__Number__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNumberAccess().getAlternatives());
+ }
+ // InternalOXtype.g:1727:3: ( rule__Number__Alternatives )
+ // InternalOXtype.g:1727:4: rule__Number__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__Number__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNumberAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+ myHiddenTokenState.restore();
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleNumber"
+
+
+ // $ANTLR start "entryRuleJvmTypeReference"
+ // InternalOXtype.g:1737:1: entryRuleJvmTypeReference : ruleJvmTypeReference EOF ;
+ public final void entryRuleJvmTypeReference() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1738:1: ( ruleJvmTypeReference EOF )
+ // InternalOXtype.g:1739:1: ruleJvmTypeReference EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmTypeReferenceRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmTypeReferenceRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleJvmTypeReference"
+
+
+ // $ANTLR start "ruleJvmTypeReference"
+ // InternalOXtype.g:1746:1: ruleJvmTypeReference : ( ( rule__JvmTypeReference__Alternatives ) ) ;
+ public final void ruleJvmTypeReference() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1750:2: ( ( ( rule__JvmTypeReference__Alternatives ) ) )
+ // InternalOXtype.g:1751:2: ( ( rule__JvmTypeReference__Alternatives ) )
+ {
+ // InternalOXtype.g:1751:2: ( ( rule__JvmTypeReference__Alternatives ) )
+ // InternalOXtype.g:1752:3: ( rule__JvmTypeReference__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmTypeReferenceAccess().getAlternatives());
+ }
+ // InternalOXtype.g:1753:3: ( rule__JvmTypeReference__Alternatives )
+ // InternalOXtype.g:1753:4: rule__JvmTypeReference__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmTypeReference__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmTypeReferenceAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleJvmTypeReference"
+
+
+ // $ANTLR start "entryRuleArrayBrackets"
+ // InternalOXtype.g:1762:1: entryRuleArrayBrackets : ruleArrayBrackets EOF ;
+ public final void entryRuleArrayBrackets() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1763:1: ( ruleArrayBrackets EOF )
+ // InternalOXtype.g:1764:1: ruleArrayBrackets EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArrayBracketsRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleArrayBrackets();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArrayBracketsRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleArrayBrackets"
+
+
+ // $ANTLR start "ruleArrayBrackets"
+ // InternalOXtype.g:1771:1: ruleArrayBrackets : ( ( rule__ArrayBrackets__Group__0 ) ) ;
+ public final void ruleArrayBrackets() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1775:2: ( ( ( rule__ArrayBrackets__Group__0 ) ) )
+ // InternalOXtype.g:1776:2: ( ( rule__ArrayBrackets__Group__0 ) )
+ {
+ // InternalOXtype.g:1776:2: ( ( rule__ArrayBrackets__Group__0 ) )
+ // InternalOXtype.g:1777:3: ( rule__ArrayBrackets__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArrayBracketsAccess().getGroup());
+ }
+ // InternalOXtype.g:1778:3: ( rule__ArrayBrackets__Group__0 )
+ // InternalOXtype.g:1778:4: rule__ArrayBrackets__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__ArrayBrackets__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArrayBracketsAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleArrayBrackets"
+
+
+ // $ANTLR start "entryRuleXFunctionTypeRef"
+ // InternalOXtype.g:1787:1: entryRuleXFunctionTypeRef : ruleXFunctionTypeRef EOF ;
+ public final void entryRuleXFunctionTypeRef() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1788:1: ( ruleXFunctionTypeRef EOF )
+ // InternalOXtype.g:1789:1: ruleXFunctionTypeRef EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFunctionTypeRefRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleXFunctionTypeRef();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFunctionTypeRefRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleXFunctionTypeRef"
+
+
+ // $ANTLR start "ruleXFunctionTypeRef"
+ // InternalOXtype.g:1796:1: ruleXFunctionTypeRef : ( ( rule__XFunctionTypeRef__Group__0 ) ) ;
+ public final void ruleXFunctionTypeRef() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1800:2: ( ( ( rule__XFunctionTypeRef__Group__0 ) ) )
+ // InternalOXtype.g:1801:2: ( ( rule__XFunctionTypeRef__Group__0 ) )
+ {
+ // InternalOXtype.g:1801:2: ( ( rule__XFunctionTypeRef__Group__0 ) )
+ // InternalOXtype.g:1802:3: ( rule__XFunctionTypeRef__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFunctionTypeRefAccess().getGroup());
+ }
+ // InternalOXtype.g:1803:3: ( rule__XFunctionTypeRef__Group__0 )
+ // InternalOXtype.g:1803:4: rule__XFunctionTypeRef__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFunctionTypeRef__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFunctionTypeRefAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleXFunctionTypeRef"
+
+
+ // $ANTLR start "entryRuleJvmParameterizedTypeReference"
+ // InternalOXtype.g:1812:1: entryRuleJvmParameterizedTypeReference : ruleJvmParameterizedTypeReference EOF ;
+ public final void entryRuleJvmParameterizedTypeReference() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1813:1: ( ruleJvmParameterizedTypeReference EOF )
+ // InternalOXtype.g:1814:1: ruleJvmParameterizedTypeReference EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleJvmParameterizedTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleJvmParameterizedTypeReference"
+
+
+ // $ANTLR start "ruleJvmParameterizedTypeReference"
+ // InternalOXtype.g:1821:1: ruleJvmParameterizedTypeReference : ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) ;
+ public final void ruleJvmParameterizedTypeReference() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1825:2: ( ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) )
+ // InternalOXtype.g:1826:2: ( ( rule__JvmParameterizedTypeReference__Group__0 ) )
+ {
+ // InternalOXtype.g:1826:2: ( ( rule__JvmParameterizedTypeReference__Group__0 ) )
+ // InternalOXtype.g:1827:3: ( rule__JvmParameterizedTypeReference__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup());
+ }
+ // InternalOXtype.g:1828:3: ( rule__JvmParameterizedTypeReference__Group__0 )
+ // InternalOXtype.g:1828:4: rule__JvmParameterizedTypeReference__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleJvmParameterizedTypeReference"
+
+
+ // $ANTLR start "entryRuleJvmArgumentTypeReference"
+ // InternalOXtype.g:1837:1: entryRuleJvmArgumentTypeReference : ruleJvmArgumentTypeReference EOF ;
+ public final void entryRuleJvmArgumentTypeReference() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1838:1: ( ruleJvmArgumentTypeReference EOF )
+ // InternalOXtype.g:1839:1: ruleJvmArgumentTypeReference EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmArgumentTypeReferenceRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmArgumentTypeReferenceRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleJvmArgumentTypeReference"
+
+
+ // $ANTLR start "ruleJvmArgumentTypeReference"
+ // InternalOXtype.g:1846:1: ruleJvmArgumentTypeReference : ( ( rule__JvmArgumentTypeReference__Alternatives ) ) ;
+ public final void ruleJvmArgumentTypeReference() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1850:2: ( ( ( rule__JvmArgumentTypeReference__Alternatives ) ) )
+ // InternalOXtype.g:1851:2: ( ( rule__JvmArgumentTypeReference__Alternatives ) )
+ {
+ // InternalOXtype.g:1851:2: ( ( rule__JvmArgumentTypeReference__Alternatives ) )
+ // InternalOXtype.g:1852:3: ( rule__JvmArgumentTypeReference__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives());
+ }
+ // InternalOXtype.g:1853:3: ( rule__JvmArgumentTypeReference__Alternatives )
+ // InternalOXtype.g:1853:4: rule__JvmArgumentTypeReference__Alternatives
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmArgumentTypeReference__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleJvmArgumentTypeReference"
+
+
+ // $ANTLR start "entryRuleJvmWildcardTypeReference"
+ // InternalOXtype.g:1862:1: entryRuleJvmWildcardTypeReference : ruleJvmWildcardTypeReference EOF ;
+ public final void entryRuleJvmWildcardTypeReference() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1863:1: ( ruleJvmWildcardTypeReference EOF )
+ // InternalOXtype.g:1864:1: ruleJvmWildcardTypeReference EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmWildcardTypeReferenceRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleJvmWildcardTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmWildcardTypeReferenceRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleJvmWildcardTypeReference"
+
+
+ // $ANTLR start "ruleJvmWildcardTypeReference"
+ // InternalOXtype.g:1871:1: ruleJvmWildcardTypeReference : ( ( rule__JvmWildcardTypeReference__Group__0 ) ) ;
+ public final void ruleJvmWildcardTypeReference() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1875:2: ( ( ( rule__JvmWildcardTypeReference__Group__0 ) ) )
+ // InternalOXtype.g:1876:2: ( ( rule__JvmWildcardTypeReference__Group__0 ) )
+ {
+ // InternalOXtype.g:1876:2: ( ( rule__JvmWildcardTypeReference__Group__0 ) )
+ // InternalOXtype.g:1877:3: ( rule__JvmWildcardTypeReference__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup());
+ }
+ // InternalOXtype.g:1878:3: ( rule__JvmWildcardTypeReference__Group__0 )
+ // InternalOXtype.g:1878:4: rule__JvmWildcardTypeReference__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmWildcardTypeReference__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleJvmWildcardTypeReference"
+
+
+ // $ANTLR start "entryRuleJvmUpperBound"
+ // InternalOXtype.g:1887:1: entryRuleJvmUpperBound : ruleJvmUpperBound EOF ;
+ public final void entryRuleJvmUpperBound() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1888:1: ( ruleJvmUpperBound EOF )
+ // InternalOXtype.g:1889:1: ruleJvmUpperBound EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmUpperBoundRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleJvmUpperBound();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmUpperBoundRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleJvmUpperBound"
+
+
+ // $ANTLR start "ruleJvmUpperBound"
+ // InternalOXtype.g:1896:1: ruleJvmUpperBound : ( ( rule__JvmUpperBound__Group__0 ) ) ;
+ public final void ruleJvmUpperBound() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1900:2: ( ( ( rule__JvmUpperBound__Group__0 ) ) )
+ // InternalOXtype.g:1901:2: ( ( rule__JvmUpperBound__Group__0 ) )
+ {
+ // InternalOXtype.g:1901:2: ( ( rule__JvmUpperBound__Group__0 ) )
+ // InternalOXtype.g:1902:3: ( rule__JvmUpperBound__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmUpperBoundAccess().getGroup());
+ }
+ // InternalOXtype.g:1903:3: ( rule__JvmUpperBound__Group__0 )
+ // InternalOXtype.g:1903:4: rule__JvmUpperBound__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmUpperBound__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmUpperBoundAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleJvmUpperBound"
+
+
+ // $ANTLR start "entryRuleJvmUpperBoundAnded"
+ // InternalOXtype.g:1912:1: entryRuleJvmUpperBoundAnded : ruleJvmUpperBoundAnded EOF ;
+ public final void entryRuleJvmUpperBoundAnded() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1913:1: ( ruleJvmUpperBoundAnded EOF )
+ // InternalOXtype.g:1914:1: ruleJvmUpperBoundAnded EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmUpperBoundAndedRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleJvmUpperBoundAnded();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmUpperBoundAndedRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleJvmUpperBoundAnded"
+
+
+ // $ANTLR start "ruleJvmUpperBoundAnded"
+ // InternalOXtype.g:1921:1: ruleJvmUpperBoundAnded : ( ( rule__JvmUpperBoundAnded__Group__0 ) ) ;
+ public final void ruleJvmUpperBoundAnded() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1925:2: ( ( ( rule__JvmUpperBoundAnded__Group__0 ) ) )
+ // InternalOXtype.g:1926:2: ( ( rule__JvmUpperBoundAnded__Group__0 ) )
+ {
+ // InternalOXtype.g:1926:2: ( ( rule__JvmUpperBoundAnded__Group__0 ) )
+ // InternalOXtype.g:1927:3: ( rule__JvmUpperBoundAnded__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmUpperBoundAndedAccess().getGroup());
+ }
+ // InternalOXtype.g:1928:3: ( rule__JvmUpperBoundAnded__Group__0 )
+ // InternalOXtype.g:1928:4: rule__JvmUpperBoundAnded__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmUpperBoundAnded__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmUpperBoundAndedAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleJvmUpperBoundAnded"
+
+
+ // $ANTLR start "entryRuleJvmLowerBound"
+ // InternalOXtype.g:1937:1: entryRuleJvmLowerBound : ruleJvmLowerBound EOF ;
+ public final void entryRuleJvmLowerBound() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1938:1: ( ruleJvmLowerBound EOF )
+ // InternalOXtype.g:1939:1: ruleJvmLowerBound EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmLowerBoundRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleJvmLowerBound();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmLowerBoundRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleJvmLowerBound"
+
+
+ // $ANTLR start "ruleJvmLowerBound"
+ // InternalOXtype.g:1946:1: ruleJvmLowerBound : ( ( rule__JvmLowerBound__Group__0 ) ) ;
+ public final void ruleJvmLowerBound() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1950:2: ( ( ( rule__JvmLowerBound__Group__0 ) ) )
+ // InternalOXtype.g:1951:2: ( ( rule__JvmLowerBound__Group__0 ) )
+ {
+ // InternalOXtype.g:1951:2: ( ( rule__JvmLowerBound__Group__0 ) )
+ // InternalOXtype.g:1952:3: ( rule__JvmLowerBound__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmLowerBoundAccess().getGroup());
+ }
+ // InternalOXtype.g:1953:3: ( rule__JvmLowerBound__Group__0 )
+ // InternalOXtype.g:1953:4: rule__JvmLowerBound__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmLowerBound__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmLowerBoundAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleJvmLowerBound"
+
+
+ // $ANTLR start "entryRuleJvmLowerBoundAnded"
+ // InternalOXtype.g:1962:1: entryRuleJvmLowerBoundAnded : ruleJvmLowerBoundAnded EOF ;
+ public final void entryRuleJvmLowerBoundAnded() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1963:1: ( ruleJvmLowerBoundAnded EOF )
+ // InternalOXtype.g:1964:1: ruleJvmLowerBoundAnded EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmLowerBoundAndedRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleJvmLowerBoundAnded();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmLowerBoundAndedRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleJvmLowerBoundAnded"
+
+
+ // $ANTLR start "ruleJvmLowerBoundAnded"
+ // InternalOXtype.g:1971:1: ruleJvmLowerBoundAnded : ( ( rule__JvmLowerBoundAnded__Group__0 ) ) ;
+ public final void ruleJvmLowerBoundAnded() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:1975:2: ( ( ( rule__JvmLowerBoundAnded__Group__0 ) ) )
+ // InternalOXtype.g:1976:2: ( ( rule__JvmLowerBoundAnded__Group__0 ) )
+ {
+ // InternalOXtype.g:1976:2: ( ( rule__JvmLowerBoundAnded__Group__0 ) )
+ // InternalOXtype.g:1977:3: ( rule__JvmLowerBoundAnded__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmLowerBoundAndedAccess().getGroup());
+ }
+ // InternalOXtype.g:1978:3: ( rule__JvmLowerBoundAnded__Group__0 )
+ // InternalOXtype.g:1978:4: rule__JvmLowerBoundAnded__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmLowerBoundAnded__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmLowerBoundAndedAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleJvmLowerBoundAnded"
+
+
+ // $ANTLR start "entryRuleQualifiedNameWithWildcard"
+ // InternalOXtype.g:1987:1: entryRuleQualifiedNameWithWildcard : ruleQualifiedNameWithWildcard EOF ;
+ public final void entryRuleQualifiedNameWithWildcard() throws RecognitionException {
+ try {
+ // InternalOXtype.g:1988:1: ( ruleQualifiedNameWithWildcard EOF )
+ // InternalOXtype.g:1989:1: ruleQualifiedNameWithWildcard EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getQualifiedNameWithWildcardRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleQualifiedNameWithWildcard();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getQualifiedNameWithWildcardRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleQualifiedNameWithWildcard"
+
+
+ // $ANTLR start "ruleQualifiedNameWithWildcard"
+ // InternalOXtype.g:1996:1: ruleQualifiedNameWithWildcard : ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) ;
+ public final void ruleQualifiedNameWithWildcard() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2000:2: ( ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) )
+ // InternalOXtype.g:2001:2: ( ( rule__QualifiedNameWithWildcard__Group__0 ) )
+ {
+ // InternalOXtype.g:2001:2: ( ( rule__QualifiedNameWithWildcard__Group__0 ) )
+ // InternalOXtype.g:2002:3: ( rule__QualifiedNameWithWildcard__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup());
+ }
+ // InternalOXtype.g:2003:3: ( rule__QualifiedNameWithWildcard__Group__0 )
+ // InternalOXtype.g:2003:4: rule__QualifiedNameWithWildcard__Group__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__QualifiedNameWithWildcard__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleQualifiedNameWithWildcard"
+
+
+ // $ANTLR start "entryRuleValidID"
+ // InternalOXtype.g:2012:1: entryRuleValidID : ruleValidID EOF ;
+ public final void entryRuleValidID() throws RecognitionException {
+ try {
+ // InternalOXtype.g:2013:1: ( ruleValidID EOF )
+ // InternalOXtype.g:2014:1: ruleValidID EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getValidIDRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getValidIDRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleValidID"
+
+
+ // $ANTLR start "ruleValidID"
+ // InternalOXtype.g:2021:1: ruleValidID : ( RULE_ID ) ;
+ public final void ruleValidID() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2025:2: ( ( RULE_ID ) )
+ // InternalOXtype.g:2026:2: ( RULE_ID )
+ {
+ // InternalOXtype.g:2026:2: ( RULE_ID )
+ // InternalOXtype.g:2027:3: RULE_ID
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getValidIDAccess().getIDTerminalRuleCall());
+ }
+ match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getValidIDAccess().getIDTerminalRuleCall());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleValidID"
+
+
+ // $ANTLR start "entryRuleQualifiedNameInStaticImport"
+ // InternalOXtype.g:2037:1: entryRuleQualifiedNameInStaticImport : ruleQualifiedNameInStaticImport EOF ;
+ public final void entryRuleQualifiedNameInStaticImport() throws RecognitionException {
+ try {
+ // InternalOXtype.g:2038:1: ( ruleQualifiedNameInStaticImport EOF )
+ // InternalOXtype.g:2039:1: ruleQualifiedNameInStaticImport EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getQualifiedNameInStaticImportRule());
+ }
+ pushFollow(FOLLOW_1);
+ ruleQualifiedNameInStaticImport();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getQualifiedNameInStaticImportRule());
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleQualifiedNameInStaticImport"
+
+
+ // $ANTLR start "ruleQualifiedNameInStaticImport"
+ // InternalOXtype.g:2046:1: ruleQualifiedNameInStaticImport : ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) ;
+ public final void ruleQualifiedNameInStaticImport() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2050:2: ( ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) )
+ // InternalOXtype.g:2051:2: ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) )
+ {
+ // InternalOXtype.g:2051:2: ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) )
+ // InternalOXtype.g:2052:3: ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* )
+ {
+ // InternalOXtype.g:2052:3: ( ( rule__QualifiedNameInStaticImport__Group__0 ) )
+ // InternalOXtype.g:2053:4: ( rule__QualifiedNameInStaticImport__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup());
+ }
+ // InternalOXtype.g:2054:4: ( rule__QualifiedNameInStaticImport__Group__0 )
+ // InternalOXtype.g:2054:5: rule__QualifiedNameInStaticImport__Group__0
+ {
+ pushFollow(FOLLOW_3);
+ rule__QualifiedNameInStaticImport__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup());
+ }
+
+ }
+
+ // InternalOXtype.g:2057:3: ( ( rule__QualifiedNameInStaticImport__Group__0 )* )
+ // InternalOXtype.g:2058:4: ( rule__QualifiedNameInStaticImport__Group__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup());
+ }
+ // InternalOXtype.g:2059:4: ( rule__QualifiedNameInStaticImport__Group__0 )*
+ loop1:
+ do {
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( (LA1_0==RULE_ID) ) {
+ int LA1_2 = input.LA(2);
+
+ if ( (LA1_2==43) ) {
+ alt1=1;
+ }
+
+
+ }
+
+
+ switch (alt1) {
+ case 1 :
+ // InternalOXtype.g:2059:5: rule__QualifiedNameInStaticImport__Group__0
+ {
+ pushFollow(FOLLOW_3);
+ rule__QualifiedNameInStaticImport__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop1;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleQualifiedNameInStaticImport"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Alternatives_2"
+ // InternalOXtype.g:2068:1: rule__XImportDeclaration__Alternatives_2 : ( ( ( rule__XImportDeclaration__Group_2_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_2_2 ) ) | ( ( rule__XImportDeclaration__Group_2_3__0 ) ) );
+ public final void rule__XImportDeclaration__Alternatives_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2072:1: ( ( ( rule__XImportDeclaration__Group_2_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_2_2 ) ) | ( ( rule__XImportDeclaration__Group_2_3__0 ) ) )
+ int alt2=4;
+ alt2 = dfa2.predict(input);
+ switch (alt2) {
+ case 1 :
+ // InternalOXtype.g:2073:2: ( ( rule__XImportDeclaration__Group_2_0__0 ) )
+ {
+ // InternalOXtype.g:2073:2: ( ( rule__XImportDeclaration__Group_2_0__0 ) )
+ // InternalOXtype.g:2074:3: ( rule__XImportDeclaration__Group_2_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getGroup_2_0());
+ }
+ // InternalOXtype.g:2075:3: ( rule__XImportDeclaration__Group_2_0__0 )
+ // InternalOXtype.g:2075:4: rule__XImportDeclaration__Group_2_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__Group_2_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getGroup_2_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2079:2: ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_1 ) )
+ {
+ // InternalOXtype.g:2079:2: ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_1 ) )
+ // InternalOXtype.g:2080:3: ( rule__XImportDeclaration__ImportedTypeAssignment_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_1());
+ }
+ // InternalOXtype.g:2081:3: ( rule__XImportDeclaration__ImportedTypeAssignment_2_1 )
+ // InternalOXtype.g:2081:4: rule__XImportDeclaration__ImportedTypeAssignment_2_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__ImportedTypeAssignment_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:2085:2: ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_2_2 ) )
+ {
+ // InternalOXtype.g:2085:2: ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_2_2 ) )
+ // InternalOXtype.g:2086:3: ( rule__XImportDeclaration__ImportedNamespaceAssignment_2_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_2_2());
+ }
+ // InternalOXtype.g:2087:3: ( rule__XImportDeclaration__ImportedNamespaceAssignment_2_2 )
+ // InternalOXtype.g:2087:4: rule__XImportDeclaration__ImportedNamespaceAssignment_2_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__ImportedNamespaceAssignment_2_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_2_2());
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:2091:2: ( ( rule__XImportDeclaration__Group_2_3__0 ) )
+ {
+ // InternalOXtype.g:2091:2: ( ( rule__XImportDeclaration__Group_2_3__0 ) )
+ // InternalOXtype.g:2092:3: ( rule__XImportDeclaration__Group_2_3__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getGroup_2_3());
+ }
+ // InternalOXtype.g:2093:3: ( rule__XImportDeclaration__Group_2_3__0 )
+ // InternalOXtype.g:2093:4: rule__XImportDeclaration__Group_2_3__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__Group_2_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getGroup_2_3());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Alternatives_2"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Alternatives_2_0_3"
+ // InternalOXtype.g:2101:1: rule__XImportDeclaration__Alternatives_2_0_3 : ( ( ( rule__XImportDeclaration__WildcardAssignment_2_0_3_0 ) ) | ( ( rule__XImportDeclaration__MemberNameAssignment_2_0_3_1 ) ) );
+ public final void rule__XImportDeclaration__Alternatives_2_0_3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2105:1: ( ( ( rule__XImportDeclaration__WildcardAssignment_2_0_3_0 ) ) | ( ( rule__XImportDeclaration__MemberNameAssignment_2_0_3_1 ) ) )
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( (LA3_0==36) ) {
+ alt3=1;
+ }
+ else if ( (LA3_0==RULE_ID) ) {
+ alt3=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 3, 0, input);
+
+ throw nvae;
+ }
+ switch (alt3) {
+ case 1 :
+ // InternalOXtype.g:2106:2: ( ( rule__XImportDeclaration__WildcardAssignment_2_0_3_0 ) )
+ {
+ // InternalOXtype.g:2106:2: ( ( rule__XImportDeclaration__WildcardAssignment_2_0_3_0 ) )
+ // InternalOXtype.g:2107:3: ( rule__XImportDeclaration__WildcardAssignment_2_0_3_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_2_0_3_0());
+ }
+ // InternalOXtype.g:2108:3: ( rule__XImportDeclaration__WildcardAssignment_2_0_3_0 )
+ // InternalOXtype.g:2108:4: rule__XImportDeclaration__WildcardAssignment_2_0_3_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__WildcardAssignment_2_0_3_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_2_0_3_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2112:2: ( ( rule__XImportDeclaration__MemberNameAssignment_2_0_3_1 ) )
+ {
+ // InternalOXtype.g:2112:2: ( ( rule__XImportDeclaration__MemberNameAssignment_2_0_3_1 ) )
+ // InternalOXtype.g:2113:3: ( rule__XImportDeclaration__MemberNameAssignment_2_0_3_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_2_0_3_1());
+ }
+ // InternalOXtype.g:2114:3: ( rule__XImportDeclaration__MemberNameAssignment_2_0_3_1 )
+ // InternalOXtype.g:2114:4: rule__XImportDeclaration__MemberNameAssignment_2_0_3_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__MemberNameAssignment_2_0_3_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_2_0_3_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Alternatives_2_0_3"
+
+
+ // $ANTLR start "rule__XAnnotation__Alternatives_3_1"
+ // InternalOXtype.g:2122:1: rule__XAnnotation__Alternatives_3_1 : ( ( ( rule__XAnnotation__Group_3_1_0__0 ) ) | ( ( rule__XAnnotation__ValueAssignment_3_1_1 ) ) );
+ public final void rule__XAnnotation__Alternatives_3_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2126:1: ( ( ( rule__XAnnotation__Group_3_1_0__0 ) ) | ( ( rule__XAnnotation__ValueAssignment_3_1_1 ) ) )
+ int alt4=2;
+ alt4 = dfa4.predict(input);
+ switch (alt4) {
+ case 1 :
+ // InternalOXtype.g:2127:2: ( ( rule__XAnnotation__Group_3_1_0__0 ) )
+ {
+ // InternalOXtype.g:2127:2: ( ( rule__XAnnotation__Group_3_1_0__0 ) )
+ // InternalOXtype.g:2128:3: ( rule__XAnnotation__Group_3_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getGroup_3_1_0());
+ }
+ // InternalOXtype.g:2129:3: ( rule__XAnnotation__Group_3_1_0__0 )
+ // InternalOXtype.g:2129:4: rule__XAnnotation__Group_3_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__Group_3_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getGroup_3_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2133:2: ( ( rule__XAnnotation__ValueAssignment_3_1_1 ) )
+ {
+ // InternalOXtype.g:2133:2: ( ( rule__XAnnotation__ValueAssignment_3_1_1 ) )
+ // InternalOXtype.g:2134:3: ( rule__XAnnotation__ValueAssignment_3_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getValueAssignment_3_1_1());
+ }
+ // InternalOXtype.g:2135:3: ( rule__XAnnotation__ValueAssignment_3_1_1 )
+ // InternalOXtype.g:2135:4: rule__XAnnotation__ValueAssignment_3_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__ValueAssignment_3_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getValueAssignment_3_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Alternatives_3_1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Alternatives"
+ // InternalOXtype.g:2143:1: rule__XAnnotationElementValueOrCommaList__Alternatives : ( ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) ) | ( ( rule__XAnnotationElementValueOrCommaList__Group_1__0 ) ) );
+ public final void rule__XAnnotationElementValueOrCommaList__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2147:1: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) ) | ( ( rule__XAnnotationElementValueOrCommaList__Group_1__0 ) ) )
+ int alt5=2;
+ alt5 = dfa5.predict(input);
+ switch (alt5) {
+ case 1 :
+ // InternalOXtype.g:2148:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) )
+ {
+ // InternalOXtype.g:2148:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) )
+ // InternalOXtype.g:2149:3: ( rule__XAnnotationElementValueOrCommaList__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0());
+ }
+ // InternalOXtype.g:2150:3: ( rule__XAnnotationElementValueOrCommaList__Group_0__0 )
+ // InternalOXtype.g:2150:4: rule__XAnnotationElementValueOrCommaList__Group_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2154:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_1__0 ) )
+ {
+ // InternalOXtype.g:2154:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_1__0 ) )
+ // InternalOXtype.g:2155:3: ( rule__XAnnotationElementValueOrCommaList__Group_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1());
+ }
+ // InternalOXtype.g:2156:3: ( rule__XAnnotationElementValueOrCommaList__Group_1__0 )
+ // InternalOXtype.g:2156:4: rule__XAnnotationElementValueOrCommaList__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Alternatives"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Alternatives"
+ // InternalOXtype.g:2164:1: rule__XAnnotationElementValue__Alternatives : ( ( ( rule__XAnnotationElementValue__Group_0__0 ) ) | ( ruleXAnnotationOrExpression ) );
+ public final void rule__XAnnotationElementValue__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2168:1: ( ( ( rule__XAnnotationElementValue__Group_0__0 ) ) | ( ruleXAnnotationOrExpression ) )
+ int alt6=2;
+ alt6 = dfa6.predict(input);
+ switch (alt6) {
+ case 1 :
+ // InternalOXtype.g:2169:2: ( ( rule__XAnnotationElementValue__Group_0__0 ) )
+ {
+ // InternalOXtype.g:2169:2: ( ( rule__XAnnotationElementValue__Group_0__0 ) )
+ // InternalOXtype.g:2170:3: ( rule__XAnnotationElementValue__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0());
+ }
+ // InternalOXtype.g:2171:3: ( rule__XAnnotationElementValue__Group_0__0 )
+ // InternalOXtype.g:2171:4: rule__XAnnotationElementValue__Group_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2175:2: ( ruleXAnnotationOrExpression )
+ {
+ // InternalOXtype.g:2175:2: ( ruleXAnnotationOrExpression )
+ // InternalOXtype.g:2176:3: ruleXAnnotationOrExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAnnotationOrExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Alternatives"
+
+
+ // $ANTLR start "rule__XAnnotationOrExpression__Alternatives"
+ // InternalOXtype.g:2185:1: rule__XAnnotationOrExpression__Alternatives : ( ( ruleXAnnotation ) | ( ruleXExpression ) );
+ public final void rule__XAnnotationOrExpression__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2189:1: ( ( ruleXAnnotation ) | ( ruleXExpression ) )
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( (LA7_0==52) ) {
+ alt7=1;
+ }
+ else if ( ((LA7_0>=RULE_ID && LA7_0<=RULE_STRING)||LA7_0==27||(LA7_0>=34 && LA7_0<=35)||LA7_0==40||(LA7_0>=45 && LA7_0<=50)||LA7_0==53||(LA7_0>=57 && LA7_0<=58)||LA7_0==61||LA7_0==63||LA7_0==65||(LA7_0>=69 && LA7_0<=77)||LA7_0==79||LA7_0==88) ) {
+ alt7=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 7, 0, input);
+
+ throw nvae;
+ }
+ switch (alt7) {
+ case 1 :
+ // InternalOXtype.g:2190:2: ( ruleXAnnotation )
+ {
+ // InternalOXtype.g:2190:2: ( ruleXAnnotation )
+ // InternalOXtype.g:2191:3: ruleXAnnotation
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAnnotation();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2196:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:2196:2: ( ruleXExpression )
+ // InternalOXtype.g:2197:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationOrExpression__Alternatives"
+
+
+ // $ANTLR start "rule__XAssignment__Alternatives"
+ // InternalOXtype.g:2206:1: rule__XAssignment__Alternatives : ( ( ( rule__XAssignment__Group_0__0 ) ) | ( ( rule__XAssignment__Group_1__0 ) ) );
+ public final void rule__XAssignment__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2210:1: ( ( ( rule__XAssignment__Group_0__0 ) ) | ( ( rule__XAssignment__Group_1__0 ) ) )
+ int alt8=2;
+ switch ( input.LA(1) ) {
+ case RULE_ID:
+ {
+ int LA8_1 = input.LA(2);
+
+ if ( (LA8_1==13) ) {
+ alt8=1;
+ }
+ else if ( (LA8_1==EOF||(LA8_1>=RULE_ID && LA8_1<=RULE_STRING)||(LA8_1>=14 && LA8_1<=51)||(LA8_1>=53 && LA8_1<=80)||(LA8_1>=84 && LA8_1<=85)||(LA8_1>=87 && LA8_1<=88)) ) {
+ alt8=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 8, 1, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case 45:
+ {
+ int LA8_2 = input.LA(2);
+
+ if ( (LA8_2==EOF||(LA8_2>=RULE_ID && LA8_2<=RULE_STRING)||(LA8_2>=14 && LA8_2<=51)||(LA8_2>=53 && LA8_2<=80)||(LA8_2>=84 && LA8_2<=85)||(LA8_2>=87 && LA8_2<=88)) ) {
+ alt8=2;
+ }
+ else if ( (LA8_2==13) ) {
+ alt8=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 8, 2, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case 46:
+ {
+ int LA8_3 = input.LA(2);
+
+ if ( (LA8_3==13) ) {
+ alt8=1;
+ }
+ else if ( (LA8_3==EOF||(LA8_3>=RULE_ID && LA8_3<=RULE_STRING)||(LA8_3>=14 && LA8_3<=51)||(LA8_3>=53 && LA8_3<=80)||(LA8_3>=84 && LA8_3<=85)||(LA8_3>=87 && LA8_3<=88)) ) {
+ alt8=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 8, 3, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case 47:
+ {
+ int LA8_4 = input.LA(2);
+
+ if ( (LA8_4==EOF||(LA8_4>=RULE_ID && LA8_4<=RULE_STRING)||(LA8_4>=14 && LA8_4<=51)||(LA8_4>=53 && LA8_4<=80)||(LA8_4>=84 && LA8_4<=85)||(LA8_4>=87 && LA8_4<=88)) ) {
+ alt8=2;
+ }
+ else if ( (LA8_4==13) ) {
+ alt8=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 8, 4, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case 48:
+ {
+ int LA8_5 = input.LA(2);
+
+ if ( (LA8_5==13) ) {
+ alt8=1;
+ }
+ else if ( (LA8_5==EOF||(LA8_5>=RULE_ID && LA8_5<=RULE_STRING)||(LA8_5>=14 && LA8_5<=51)||(LA8_5>=53 && LA8_5<=80)||(LA8_5>=84 && LA8_5<=85)||(LA8_5>=87 && LA8_5<=88)) ) {
+ alt8=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 8, 5, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case RULE_HEX:
+ case RULE_INT:
+ case RULE_DECIMAL:
+ case RULE_STRING:
+ case 27:
+ case 34:
+ case 35:
+ case 40:
+ case 49:
+ case 50:
+ case 53:
+ case 57:
+ case 58:
+ case 61:
+ case 63:
+ case 65:
+ case 69:
+ case 70:
+ case 71:
+ case 72:
+ case 73:
+ case 74:
+ case 75:
+ case 76:
+ case 77:
+ case 79:
+ case 88:
+ {
+ alt8=2;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 8, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt8) {
+ case 1 :
+ // InternalOXtype.g:2211:2: ( ( rule__XAssignment__Group_0__0 ) )
+ {
+ // InternalOXtype.g:2211:2: ( ( rule__XAssignment__Group_0__0 ) )
+ // InternalOXtype.g:2212:3: ( rule__XAssignment__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getGroup_0());
+ }
+ // InternalOXtype.g:2213:3: ( rule__XAssignment__Group_0__0 )
+ // InternalOXtype.g:2213:4: rule__XAssignment__Group_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2217:2: ( ( rule__XAssignment__Group_1__0 ) )
+ {
+ // InternalOXtype.g:2217:2: ( ( rule__XAssignment__Group_1__0 ) )
+ // InternalOXtype.g:2218:3: ( rule__XAssignment__Group_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getGroup_1());
+ }
+ // InternalOXtype.g:2219:3: ( rule__XAssignment__Group_1__0 )
+ // InternalOXtype.g:2219:4: rule__XAssignment__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Alternatives"
+
+
+ // $ANTLR start "rule__OpMultiAssign__Alternatives"
+ // InternalOXtype.g:2227:1: rule__OpMultiAssign__Alternatives : ( ( '+=' ) | ( '-=' ) | ( '*=' ) | ( '/=' ) | ( '%=' ) | ( ( rule__OpMultiAssign__Group_5__0 ) ) | ( ( rule__OpMultiAssign__Group_6__0 ) ) );
+ public final void rule__OpMultiAssign__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2231:1: ( ( '+=' ) | ( '-=' ) | ( '*=' ) | ( '/=' ) | ( '%=' ) | ( ( rule__OpMultiAssign__Group_5__0 ) ) | ( ( rule__OpMultiAssign__Group_6__0 ) ) )
+ int alt9=7;
+ switch ( input.LA(1) ) {
+ case 16:
+ {
+ alt9=1;
+ }
+ break;
+ case 17:
+ {
+ alt9=2;
+ }
+ break;
+ case 18:
+ {
+ alt9=3;
+ }
+ break;
+ case 19:
+ {
+ alt9=4;
+ }
+ break;
+ case 20:
+ {
+ alt9=5;
+ }
+ break;
+ case 27:
+ {
+ alt9=6;
+ }
+ break;
+ case 26:
+ {
+ alt9=7;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 9, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt9) {
+ case 1 :
+ // InternalOXtype.g:2232:2: ( '+=' )
+ {
+ // InternalOXtype.g:2232:2: ( '+=' )
+ // InternalOXtype.g:2233:3: '+='
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0());
+ }
+ match(input,16,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2238:2: ( '-=' )
+ {
+ // InternalOXtype.g:2238:2: ( '-=' )
+ // InternalOXtype.g:2239:3: '-='
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1());
+ }
+ match(input,17,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:2244:2: ( '*=' )
+ {
+ // InternalOXtype.g:2244:2: ( '*=' )
+ // InternalOXtype.g:2245:3: '*='
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2());
+ }
+ match(input,18,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2());
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:2250:2: ( '/=' )
+ {
+ // InternalOXtype.g:2250:2: ( '/=' )
+ // InternalOXtype.g:2251:3: '/='
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3());
+ }
+ match(input,19,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3());
+ }
+
+ }
+
+
+ }
+ break;
+ case 5 :
+ // InternalOXtype.g:2256:2: ( '%=' )
+ {
+ // InternalOXtype.g:2256:2: ( '%=' )
+ // InternalOXtype.g:2257:3: '%='
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4());
+ }
+ match(input,20,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4());
+ }
+
+ }
+
+
+ }
+ break;
+ case 6 :
+ // InternalOXtype.g:2262:2: ( ( rule__OpMultiAssign__Group_5__0 ) )
+ {
+ // InternalOXtype.g:2262:2: ( ( rule__OpMultiAssign__Group_5__0 ) )
+ // InternalOXtype.g:2263:3: ( rule__OpMultiAssign__Group_5__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAssignAccess().getGroup_5());
+ }
+ // InternalOXtype.g:2264:3: ( rule__OpMultiAssign__Group_5__0 )
+ // InternalOXtype.g:2264:4: rule__OpMultiAssign__Group_5__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpMultiAssign__Group_5__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAssignAccess().getGroup_5());
+ }
+
+ }
+
+
+ }
+ break;
+ case 7 :
+ // InternalOXtype.g:2268:2: ( ( rule__OpMultiAssign__Group_6__0 ) )
+ {
+ // InternalOXtype.g:2268:2: ( ( rule__OpMultiAssign__Group_6__0 ) )
+ // InternalOXtype.g:2269:3: ( rule__OpMultiAssign__Group_6__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAssignAccess().getGroup_6());
+ }
+ // InternalOXtype.g:2270:3: ( rule__OpMultiAssign__Group_6__0 )
+ // InternalOXtype.g:2270:4: rule__OpMultiAssign__Group_6__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpMultiAssign__Group_6__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAssignAccess().getGroup_6());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpMultiAssign__Alternatives"
+
+
+ // $ANTLR start "rule__OpEquality__Alternatives"
+ // InternalOXtype.g:2278:1: rule__OpEquality__Alternatives : ( ( '==' ) | ( '!=' ) | ( '===' ) | ( '!==' ) );
+ public final void rule__OpEquality__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2282:1: ( ( '==' ) | ( '!=' ) | ( '===' ) | ( '!==' ) )
+ int alt10=4;
+ switch ( input.LA(1) ) {
+ case 21:
+ {
+ alt10=1;
+ }
+ break;
+ case 22:
+ {
+ alt10=2;
+ }
+ break;
+ case 23:
+ {
+ alt10=3;
+ }
+ break;
+ case 24:
+ {
+ alt10=4;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 10, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt10) {
+ case 1 :
+ // InternalOXtype.g:2283:2: ( '==' )
+ {
+ // InternalOXtype.g:2283:2: ( '==' )
+ // InternalOXtype.g:2284:3: '=='
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0());
+ }
+ match(input,21,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2289:2: ( '!=' )
+ {
+ // InternalOXtype.g:2289:2: ( '!=' )
+ // InternalOXtype.g:2290:3: '!='
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1());
+ }
+ match(input,22,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:2295:2: ( '===' )
+ {
+ // InternalOXtype.g:2295:2: ( '===' )
+ // InternalOXtype.g:2296:3: '==='
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2());
+ }
+ match(input,23,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2());
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:2301:2: ( '!==' )
+ {
+ // InternalOXtype.g:2301:2: ( '!==' )
+ // InternalOXtype.g:2302:3: '!=='
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3());
+ }
+ match(input,24,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpEquality__Alternatives"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Alternatives_1"
+ // InternalOXtype.g:2311:1: rule__XRelationalExpression__Alternatives_1 : ( ( ( rule__XRelationalExpression__Group_1_0__0 ) ) | ( ( rule__XRelationalExpression__Group_1_1__0 ) ) );
+ public final void rule__XRelationalExpression__Alternatives_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2315:1: ( ( ( rule__XRelationalExpression__Group_1_0__0 ) ) | ( ( rule__XRelationalExpression__Group_1_1__0 ) ) )
+ int alt11=2;
+ int LA11_0 = input.LA(1);
+
+ if ( (LA11_0==59) ) {
+ alt11=1;
+ }
+ else if ( ((LA11_0>=25 && LA11_0<=27)) ) {
+ alt11=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 11, 0, input);
+
+ throw nvae;
+ }
+ switch (alt11) {
+ case 1 :
+ // InternalOXtype.g:2316:2: ( ( rule__XRelationalExpression__Group_1_0__0 ) )
+ {
+ // InternalOXtype.g:2316:2: ( ( rule__XRelationalExpression__Group_1_0__0 ) )
+ // InternalOXtype.g:2317:3: ( rule__XRelationalExpression__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0());
+ }
+ // InternalOXtype.g:2318:3: ( rule__XRelationalExpression__Group_1_0__0 )
+ // InternalOXtype.g:2318:4: rule__XRelationalExpression__Group_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2322:2: ( ( rule__XRelationalExpression__Group_1_1__0 ) )
+ {
+ // InternalOXtype.g:2322:2: ( ( rule__XRelationalExpression__Group_1_1__0 ) )
+ // InternalOXtype.g:2323:3: ( rule__XRelationalExpression__Group_1_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1());
+ }
+ // InternalOXtype.g:2324:3: ( rule__XRelationalExpression__Group_1_1__0 )
+ // InternalOXtype.g:2324:4: rule__XRelationalExpression__Group_1_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Alternatives_1"
+
+
+ // $ANTLR start "rule__OpCompare__Alternatives"
+ // InternalOXtype.g:2332:1: rule__OpCompare__Alternatives : ( ( '>=' ) | ( ( rule__OpCompare__Group_1__0 ) ) | ( '>' ) | ( '<' ) );
+ public final void rule__OpCompare__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2336:1: ( ( '>=' ) | ( ( rule__OpCompare__Group_1__0 ) ) | ( '>' ) | ( '<' ) )
+ int alt12=4;
+ switch ( input.LA(1) ) {
+ case 25:
+ {
+ alt12=1;
+ }
+ break;
+ case 27:
+ {
+ int LA12_2 = input.LA(2);
+
+ if ( (LA12_2==13) ) {
+ alt12=2;
+ }
+ else if ( (LA12_2==EOF||(LA12_2>=RULE_ID && LA12_2<=RULE_STRING)||LA12_2==27||(LA12_2>=34 && LA12_2<=35)||LA12_2==40||(LA12_2>=45 && LA12_2<=50)||LA12_2==53||(LA12_2>=57 && LA12_2<=58)||LA12_2==61||LA12_2==63||LA12_2==65||(LA12_2>=69 && LA12_2<=77)||LA12_2==79||LA12_2==88) ) {
+ alt12=4;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 12, 2, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case 26:
+ {
+ alt12=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 12, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt12) {
+ case 1 :
+ // InternalOXtype.g:2337:2: ( '>=' )
+ {
+ // InternalOXtype.g:2337:2: ( '>=' )
+ // InternalOXtype.g:2338:3: '>='
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0());
+ }
+ match(input,25,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2343:2: ( ( rule__OpCompare__Group_1__0 ) )
+ {
+ // InternalOXtype.g:2343:2: ( ( rule__OpCompare__Group_1__0 ) )
+ // InternalOXtype.g:2344:3: ( rule__OpCompare__Group_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpCompareAccess().getGroup_1());
+ }
+ // InternalOXtype.g:2345:3: ( rule__OpCompare__Group_1__0 )
+ // InternalOXtype.g:2345:4: rule__OpCompare__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpCompare__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpCompareAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:2349:2: ( '>' )
+ {
+ // InternalOXtype.g:2349:2: ( '>' )
+ // InternalOXtype.g:2350:3: '>'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2());
+ }
+ match(input,26,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2());
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:2355:2: ( '<' )
+ {
+ // InternalOXtype.g:2355:2: ( '<' )
+ // InternalOXtype.g:2356:3: '<'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3());
+ }
+ match(input,27,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpCompare__Alternatives"
+
+
+ // $ANTLR start "rule__OpOther__Alternatives"
+ // InternalOXtype.g:2365:1: rule__OpOther__Alternatives : ( ( '->' ) | ( '..<' ) | ( ( rule__OpOther__Group_2__0 ) ) | ( '..' ) | ( '=>' ) | ( ( rule__OpOther__Group_5__0 ) ) | ( ( rule__OpOther__Group_6__0 ) ) | ( '<>' ) | ( '?:' ) );
+ public final void rule__OpOther__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2369:1: ( ( '->' ) | ( '..<' ) | ( ( rule__OpOther__Group_2__0 ) ) | ( '..' ) | ( '=>' ) | ( ( rule__OpOther__Group_5__0 ) ) | ( ( rule__OpOther__Group_6__0 ) ) | ( '<>' ) | ( '?:' ) )
+ int alt13=9;
+ alt13 = dfa13.predict(input);
+ switch (alt13) {
+ case 1 :
+ // InternalOXtype.g:2370:2: ( '->' )
+ {
+ // InternalOXtype.g:2370:2: ( '->' )
+ // InternalOXtype.g:2371:3: '->'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0());
+ }
+ match(input,28,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2376:2: ( '..<' )
+ {
+ // InternalOXtype.g:2376:2: ( '..<' )
+ // InternalOXtype.g:2377:3: '..<'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1());
+ }
+ match(input,29,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:2382:2: ( ( rule__OpOther__Group_2__0 ) )
+ {
+ // InternalOXtype.g:2382:2: ( ( rule__OpOther__Group_2__0 ) )
+ // InternalOXtype.g:2383:3: ( rule__OpOther__Group_2__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getGroup_2());
+ }
+ // InternalOXtype.g:2384:3: ( rule__OpOther__Group_2__0 )
+ // InternalOXtype.g:2384:4: rule__OpOther__Group_2__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getGroup_2());
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:2388:2: ( '..' )
+ {
+ // InternalOXtype.g:2388:2: ( '..' )
+ // InternalOXtype.g:2389:3: '..'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3());
+ }
+ match(input,30,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3());
+ }
+
+ }
+
+
+ }
+ break;
+ case 5 :
+ // InternalOXtype.g:2394:2: ( '=>' )
+ {
+ // InternalOXtype.g:2394:2: ( '=>' )
+ // InternalOXtype.g:2395:3: '=>'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4());
+ }
+ match(input,31,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4());
+ }
+
+ }
+
+
+ }
+ break;
+ case 6 :
+ // InternalOXtype.g:2400:2: ( ( rule__OpOther__Group_5__0 ) )
+ {
+ // InternalOXtype.g:2400:2: ( ( rule__OpOther__Group_5__0 ) )
+ // InternalOXtype.g:2401:3: ( rule__OpOther__Group_5__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getGroup_5());
+ }
+ // InternalOXtype.g:2402:3: ( rule__OpOther__Group_5__0 )
+ // InternalOXtype.g:2402:4: rule__OpOther__Group_5__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_5__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getGroup_5());
+ }
+
+ }
+
+
+ }
+ break;
+ case 7 :
+ // InternalOXtype.g:2406:2: ( ( rule__OpOther__Group_6__0 ) )
+ {
+ // InternalOXtype.g:2406:2: ( ( rule__OpOther__Group_6__0 ) )
+ // InternalOXtype.g:2407:3: ( rule__OpOther__Group_6__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getGroup_6());
+ }
+ // InternalOXtype.g:2408:3: ( rule__OpOther__Group_6__0 )
+ // InternalOXtype.g:2408:4: rule__OpOther__Group_6__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_6__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getGroup_6());
+ }
+
+ }
+
+
+ }
+ break;
+ case 8 :
+ // InternalOXtype.g:2412:2: ( '<>' )
+ {
+ // InternalOXtype.g:2412:2: ( '<>' )
+ // InternalOXtype.g:2413:3: '<>'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7());
+ }
+ match(input,32,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7());
+ }
+
+ }
+
+
+ }
+ break;
+ case 9 :
+ // InternalOXtype.g:2418:2: ( '?:' )
+ {
+ // InternalOXtype.g:2418:2: ( '?:' )
+ // InternalOXtype.g:2419:3: '?:'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8());
+ }
+ match(input,33,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Alternatives"
+
+
+ // $ANTLR start "rule__OpOther__Alternatives_5_1"
+ // InternalOXtype.g:2428:1: rule__OpOther__Alternatives_5_1 : ( ( ( rule__OpOther__Group_5_1_0__0 ) ) | ( '>' ) );
+ public final void rule__OpOther__Alternatives_5_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2432:1: ( ( ( rule__OpOther__Group_5_1_0__0 ) ) | ( '>' ) )
+ int alt14=2;
+ int LA14_0 = input.LA(1);
+
+ if ( (LA14_0==26) ) {
+ int LA14_1 = input.LA(2);
+
+ if ( (LA14_1==26) ) {
+ alt14=1;
+ }
+ else if ( (LA14_1==EOF||(LA14_1>=RULE_ID && LA14_1<=RULE_STRING)||LA14_1==27||(LA14_1>=34 && LA14_1<=35)||LA14_1==40||(LA14_1>=45 && LA14_1<=50)||LA14_1==53||(LA14_1>=57 && LA14_1<=58)||LA14_1==61||LA14_1==63||LA14_1==65||(LA14_1>=69 && LA14_1<=77)||LA14_1==79||LA14_1==88) ) {
+ alt14=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 14, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 14, 0, input);
+
+ throw nvae;
+ }
+ switch (alt14) {
+ case 1 :
+ // InternalOXtype.g:2433:2: ( ( rule__OpOther__Group_5_1_0__0 ) )
+ {
+ // InternalOXtype.g:2433:2: ( ( rule__OpOther__Group_5_1_0__0 ) )
+ // InternalOXtype.g:2434:3: ( rule__OpOther__Group_5_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getGroup_5_1_0());
+ }
+ // InternalOXtype.g:2435:3: ( rule__OpOther__Group_5_1_0__0 )
+ // InternalOXtype.g:2435:4: rule__OpOther__Group_5_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_5_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getGroup_5_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2439:2: ( '>' )
+ {
+ // InternalOXtype.g:2439:2: ( '>' )
+ // InternalOXtype.g:2440:3: '>'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1());
+ }
+ match(input,26,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Alternatives_5_1"
+
+
+ // $ANTLR start "rule__OpOther__Alternatives_6_1"
+ // InternalOXtype.g:2449:1: rule__OpOther__Alternatives_6_1 : ( ( ( rule__OpOther__Group_6_1_0__0 ) ) | ( '<' ) | ( '=>' ) );
+ public final void rule__OpOther__Alternatives_6_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2453:1: ( ( ( rule__OpOther__Group_6_1_0__0 ) ) | ( '<' ) | ( '=>' ) )
+ int alt15=3;
+ int LA15_0 = input.LA(1);
+
+ if ( (LA15_0==27) ) {
+ int LA15_1 = input.LA(2);
+
+ if ( (synpred33_InternalOXtype()) ) {
+ alt15=1;
+ }
+ else if ( (synpred34_InternalOXtype()) ) {
+ alt15=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 15, 1, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA15_0==31) ) {
+ alt15=3;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 15, 0, input);
+
+ throw nvae;
+ }
+ switch (alt15) {
+ case 1 :
+ // InternalOXtype.g:2454:2: ( ( rule__OpOther__Group_6_1_0__0 ) )
+ {
+ // InternalOXtype.g:2454:2: ( ( rule__OpOther__Group_6_1_0__0 ) )
+ // InternalOXtype.g:2455:3: ( rule__OpOther__Group_6_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getGroup_6_1_0());
+ }
+ // InternalOXtype.g:2456:3: ( rule__OpOther__Group_6_1_0__0 )
+ // InternalOXtype.g:2456:4: rule__OpOther__Group_6_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_6_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getGroup_6_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2460:2: ( '<' )
+ {
+ // InternalOXtype.g:2460:2: ( '<' )
+ // InternalOXtype.g:2461:3: '<'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1());
+ }
+ match(input,27,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:2466:2: ( '=>' )
+ {
+ // InternalOXtype.g:2466:2: ( '=>' )
+ // InternalOXtype.g:2467:3: '=>'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2());
+ }
+ match(input,31,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Alternatives_6_1"
+
+
+ // $ANTLR start "rule__OpAdd__Alternatives"
+ // InternalOXtype.g:2476:1: rule__OpAdd__Alternatives : ( ( '+' ) | ( '-' ) );
+ public final void rule__OpAdd__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2480:1: ( ( '+' ) | ( '-' ) )
+ int alt16=2;
+ int LA16_0 = input.LA(1);
+
+ if ( (LA16_0==34) ) {
+ alt16=1;
+ }
+ else if ( (LA16_0==35) ) {
+ alt16=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 16, 0, input);
+
+ throw nvae;
+ }
+ switch (alt16) {
+ case 1 :
+ // InternalOXtype.g:2481:2: ( '+' )
+ {
+ // InternalOXtype.g:2481:2: ( '+' )
+ // InternalOXtype.g:2482:3: '+'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpAddAccess().getPlusSignKeyword_0());
+ }
+ match(input,34,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpAddAccess().getPlusSignKeyword_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2487:2: ( '-' )
+ {
+ // InternalOXtype.g:2487:2: ( '-' )
+ // InternalOXtype.g:2488:3: '-'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1());
+ }
+ match(input,35,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpAdd__Alternatives"
+
+
+ // $ANTLR start "rule__OpMulti__Alternatives"
+ // InternalOXtype.g:2497:1: rule__OpMulti__Alternatives : ( ( '*' ) | ( '**' ) | ( '/' ) | ( '%' ) );
+ public final void rule__OpMulti__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2501:1: ( ( '*' ) | ( '**' ) | ( '/' ) | ( '%' ) )
+ int alt17=4;
+ switch ( input.LA(1) ) {
+ case 36:
+ {
+ alt17=1;
+ }
+ break;
+ case 37:
+ {
+ alt17=2;
+ }
+ break;
+ case 38:
+ {
+ alt17=3;
+ }
+ break;
+ case 39:
+ {
+ alt17=4;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 17, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt17) {
+ case 1 :
+ // InternalOXtype.g:2502:2: ( '*' )
+ {
+ // InternalOXtype.g:2502:2: ( '*' )
+ // InternalOXtype.g:2503:3: '*'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0());
+ }
+ match(input,36,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2508:2: ( '**' )
+ {
+ // InternalOXtype.g:2508:2: ( '**' )
+ // InternalOXtype.g:2509:3: '**'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1());
+ }
+ match(input,37,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:2514:2: ( '/' )
+ {
+ // InternalOXtype.g:2514:2: ( '/' )
+ // InternalOXtype.g:2515:3: '/'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAccess().getSolidusKeyword_2());
+ }
+ match(input,38,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAccess().getSolidusKeyword_2());
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:2520:2: ( '%' )
+ {
+ // InternalOXtype.g:2520:2: ( '%' )
+ // InternalOXtype.g:2521:3: '%'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3());
+ }
+ match(input,39,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpMulti__Alternatives"
+
+
+ // $ANTLR start "rule__XUnaryOperation__Alternatives"
+ // InternalOXtype.g:2530:1: rule__XUnaryOperation__Alternatives : ( ( ( rule__XUnaryOperation__Group_0__0 ) ) | ( ruleXCastedExpression ) );
+ public final void rule__XUnaryOperation__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2534:1: ( ( ( rule__XUnaryOperation__Group_0__0 ) ) | ( ruleXCastedExpression ) )
+ int alt18=2;
+ int LA18_0 = input.LA(1);
+
+ if ( ((LA18_0>=34 && LA18_0<=35)||LA18_0==40) ) {
+ alt18=1;
+ }
+ else if ( ((LA18_0>=RULE_ID && LA18_0<=RULE_STRING)||LA18_0==27||(LA18_0>=45 && LA18_0<=50)||LA18_0==53||(LA18_0>=57 && LA18_0<=58)||LA18_0==61||LA18_0==63||LA18_0==65||(LA18_0>=69 && LA18_0<=77)||LA18_0==79||LA18_0==88) ) {
+ alt18=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 18, 0, input);
+
+ throw nvae;
+ }
+ switch (alt18) {
+ case 1 :
+ // InternalOXtype.g:2535:2: ( ( rule__XUnaryOperation__Group_0__0 ) )
+ {
+ // InternalOXtype.g:2535:2: ( ( rule__XUnaryOperation__Group_0__0 ) )
+ // InternalOXtype.g:2536:3: ( rule__XUnaryOperation__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXUnaryOperationAccess().getGroup_0());
+ }
+ // InternalOXtype.g:2537:3: ( rule__XUnaryOperation__Group_0__0 )
+ // InternalOXtype.g:2537:4: rule__XUnaryOperation__Group_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XUnaryOperation__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXUnaryOperationAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2541:2: ( ruleXCastedExpression )
+ {
+ // InternalOXtype.g:2541:2: ( ruleXCastedExpression )
+ // InternalOXtype.g:2542:3: ruleXCastedExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXCastedExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XUnaryOperation__Alternatives"
+
+
+ // $ANTLR start "rule__OpUnary__Alternatives"
+ // InternalOXtype.g:2551:1: rule__OpUnary__Alternatives : ( ( '!' ) | ( '-' ) | ( '+' ) );
+ public final void rule__OpUnary__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2555:1: ( ( '!' ) | ( '-' ) | ( '+' ) )
+ int alt19=3;
+ switch ( input.LA(1) ) {
+ case 40:
+ {
+ alt19=1;
+ }
+ break;
+ case 35:
+ {
+ alt19=2;
+ }
+ break;
+ case 34:
+ {
+ alt19=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 19, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt19) {
+ case 1 :
+ // InternalOXtype.g:2556:2: ( '!' )
+ {
+ // InternalOXtype.g:2556:2: ( '!' )
+ // InternalOXtype.g:2557:3: '!'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0());
+ }
+ match(input,40,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2562:2: ( '-' )
+ {
+ // InternalOXtype.g:2562:2: ( '-' )
+ // InternalOXtype.g:2563:3: '-'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1());
+ }
+ match(input,35,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:2568:2: ( '+' )
+ {
+ // InternalOXtype.g:2568:2: ( '+' )
+ // InternalOXtype.g:2569:3: '+'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2());
+ }
+ match(input,34,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpUnary__Alternatives"
+
+
+ // $ANTLR start "rule__OpPostfix__Alternatives"
+ // InternalOXtype.g:2578:1: rule__OpPostfix__Alternatives : ( ( '++' ) | ( '--' ) );
+ public final void rule__OpPostfix__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2582:1: ( ( '++' ) | ( '--' ) )
+ int alt20=2;
+ int LA20_0 = input.LA(1);
+
+ if ( (LA20_0==41) ) {
+ alt20=1;
+ }
+ else if ( (LA20_0==42) ) {
+ alt20=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 20, 0, input);
+
+ throw nvae;
+ }
+ switch (alt20) {
+ case 1 :
+ // InternalOXtype.g:2583:2: ( '++' )
+ {
+ // InternalOXtype.g:2583:2: ( '++' )
+ // InternalOXtype.g:2584:3: '++'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0());
+ }
+ match(input,41,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2589:2: ( '--' )
+ {
+ // InternalOXtype.g:2589:2: ( '--' )
+ // InternalOXtype.g:2590:3: '--'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1());
+ }
+ match(input,42,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpPostfix__Alternatives"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1"
+ // InternalOXtype.g:2599:1: rule__XMemberFeatureCall__Alternatives_1 : ( ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) );
+ public final void rule__XMemberFeatureCall__Alternatives_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2603:1: ( ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) )
+ int alt21=2;
+ alt21 = dfa21.predict(input);
+ switch (alt21) {
+ case 1 :
+ // InternalOXtype.g:2604:2: ( ( rule__XMemberFeatureCall__Group_1_0__0 ) )
+ {
+ // InternalOXtype.g:2604:2: ( ( rule__XMemberFeatureCall__Group_1_0__0 ) )
+ // InternalOXtype.g:2605:3: ( rule__XMemberFeatureCall__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0());
+ }
+ // InternalOXtype.g:2606:3: ( rule__XMemberFeatureCall__Group_1_0__0 )
+ // InternalOXtype.g:2606:4: rule__XMemberFeatureCall__Group_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2610:2: ( ( rule__XMemberFeatureCall__Group_1_1__0 ) )
+ {
+ // InternalOXtype.g:2610:2: ( ( rule__XMemberFeatureCall__Group_1_1__0 ) )
+ // InternalOXtype.g:2611:3: ( rule__XMemberFeatureCall__Group_1_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1());
+ }
+ // InternalOXtype.g:2612:3: ( rule__XMemberFeatureCall__Group_1_1__0 )
+ // InternalOXtype.g:2612:4: rule__XMemberFeatureCall__Group_1_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1_0_0_0_1"
+ // InternalOXtype.g:2620:1: rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 : ( ( '.' ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) ) );
+ public final void rule__XMemberFeatureCall__Alternatives_1_0_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2624:1: ( ( '.' ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) ) )
+ int alt22=2;
+ int LA22_0 = input.LA(1);
+
+ if ( (LA22_0==43) ) {
+ alt22=1;
+ }
+ else if ( (LA22_0==84) ) {
+ alt22=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 22, 0, input);
+
+ throw nvae;
+ }
+ switch (alt22) {
+ case 1 :
+ // InternalOXtype.g:2625:2: ( '.' )
+ {
+ // InternalOXtype.g:2625:2: ( '.' )
+ // InternalOXtype.g:2626:3: '.'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0());
+ }
+ match(input,43,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2631:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) )
+ {
+ // InternalOXtype.g:2631:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) )
+ // InternalOXtype.g:2632:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1());
+ }
+ // InternalOXtype.g:2633:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 )
+ // InternalOXtype.g:2633:4: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1_0_0_0_1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1_1_0_0_1"
+ // InternalOXtype.g:2641:1: rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 : ( ( '.' ) | ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) ) );
+ public final void rule__XMemberFeatureCall__Alternatives_1_1_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2645:1: ( ( '.' ) | ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) ) )
+ int alt23=3;
+ switch ( input.LA(1) ) {
+ case 43:
+ {
+ alt23=1;
+ }
+ break;
+ case 85:
+ {
+ alt23=2;
+ }
+ break;
+ case 84:
+ {
+ alt23=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 23, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt23) {
+ case 1 :
+ // InternalOXtype.g:2646:2: ( '.' )
+ {
+ // InternalOXtype.g:2646:2: ( '.' )
+ // InternalOXtype.g:2647:3: '.'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0());
+ }
+ match(input,43,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2652:2: ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) )
+ {
+ // InternalOXtype.g:2652:2: ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) )
+ // InternalOXtype.g:2653:3: ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1());
+ }
+ // InternalOXtype.g:2654:3: ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 )
+ // InternalOXtype.g:2654:4: rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:2658:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) )
+ {
+ // InternalOXtype.g:2658:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) )
+ // InternalOXtype.g:2659:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2());
+ }
+ // InternalOXtype.g:2660:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 )
+ // InternalOXtype.g:2660:4: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1_1_0_0_1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1_1_3_1"
+ // InternalOXtype.g:2668:1: rule__XMemberFeatureCall__Alternatives_1_1_3_1 : ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) );
+ public final void rule__XMemberFeatureCall__Alternatives_1_1_3_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2672:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) )
+ int alt24=2;
+ alt24 = dfa24.predict(input);
+ switch (alt24) {
+ case 1 :
+ // InternalOXtype.g:2673:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) )
+ {
+ // InternalOXtype.g:2673:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) )
+ // InternalOXtype.g:2674:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0());
+ }
+ // InternalOXtype.g:2675:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 )
+ // InternalOXtype.g:2675:4: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2679:2: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) )
+ {
+ // InternalOXtype.g:2679:2: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) )
+ // InternalOXtype.g:2680:3: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1());
+ }
+ // InternalOXtype.g:2681:3: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 )
+ // InternalOXtype.g:2681:4: rule__XMemberFeatureCall__Group_1_1_3_1_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_3_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1_1_3_1"
+
+
+ // $ANTLR start "rule__XPrimaryExpression__Alternatives"
+ // InternalOXtype.g:2689:1: rule__XPrimaryExpression__Alternatives : ( ( ruleXConstructorCall ) | ( ruleXBlockExpression ) | ( ruleXSwitchExpression ) | ( ( ruleXSynchronizedExpression ) ) | ( ruleXFeatureCall ) | ( ruleXLiteral ) | ( ruleXIfExpression ) | ( ( ruleXForLoopExpression ) ) | ( ruleXBasicForLoopExpression ) | ( ruleXWhileExpression ) | ( ruleXDoWhileExpression ) | ( ruleXThrowExpression ) | ( ruleXReturnExpression ) | ( ruleXTryCatchFinallyExpression ) | ( ruleXParenthesizedExpression ) );
+ public final void rule__XPrimaryExpression__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2693:1: ( ( ruleXConstructorCall ) | ( ruleXBlockExpression ) | ( ruleXSwitchExpression ) | ( ( ruleXSynchronizedExpression ) ) | ( ruleXFeatureCall ) | ( ruleXLiteral ) | ( ruleXIfExpression ) | ( ( ruleXForLoopExpression ) ) | ( ruleXBasicForLoopExpression ) | ( ruleXWhileExpression ) | ( ruleXDoWhileExpression ) | ( ruleXThrowExpression ) | ( ruleXReturnExpression ) | ( ruleXTryCatchFinallyExpression ) | ( ruleXParenthesizedExpression ) )
+ int alt25=15;
+ alt25 = dfa25.predict(input);
+ switch (alt25) {
+ case 1 :
+ // InternalOXtype.g:2694:2: ( ruleXConstructorCall )
+ {
+ // InternalOXtype.g:2694:2: ( ruleXConstructorCall )
+ // InternalOXtype.g:2695:3: ruleXConstructorCall
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXConstructorCall();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2700:2: ( ruleXBlockExpression )
+ {
+ // InternalOXtype.g:2700:2: ( ruleXBlockExpression )
+ // InternalOXtype.g:2701:3: ruleXBlockExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXBlockExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:2706:2: ( ruleXSwitchExpression )
+ {
+ // InternalOXtype.g:2706:2: ( ruleXSwitchExpression )
+ // InternalOXtype.g:2707:3: ruleXSwitchExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXSwitchExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2());
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:2712:2: ( ( ruleXSynchronizedExpression ) )
+ {
+ // InternalOXtype.g:2712:2: ( ( ruleXSynchronizedExpression ) )
+ // InternalOXtype.g:2713:3: ( ruleXSynchronizedExpression )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3());
+ }
+ // InternalOXtype.g:2714:3: ( ruleXSynchronizedExpression )
+ // InternalOXtype.g:2714:4: ruleXSynchronizedExpression
+ {
+ pushFollow(FOLLOW_2);
+ ruleXSynchronizedExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3());
+ }
+
+ }
+
+
+ }
+ break;
+ case 5 :
+ // InternalOXtype.g:2718:2: ( ruleXFeatureCall )
+ {
+ // InternalOXtype.g:2718:2: ( ruleXFeatureCall )
+ // InternalOXtype.g:2719:3: ruleXFeatureCall
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXFeatureCall();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4());
+ }
+
+ }
+
+
+ }
+ break;
+ case 6 :
+ // InternalOXtype.g:2724:2: ( ruleXLiteral )
+ {
+ // InternalOXtype.g:2724:2: ( ruleXLiteral )
+ // InternalOXtype.g:2725:3: ruleXLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5());
+ }
+
+ }
+
+
+ }
+ break;
+ case 7 :
+ // InternalOXtype.g:2730:2: ( ruleXIfExpression )
+ {
+ // InternalOXtype.g:2730:2: ( ruleXIfExpression )
+ // InternalOXtype.g:2731:3: ruleXIfExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXIfExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6());
+ }
+
+ }
+
+
+ }
+ break;
+ case 8 :
+ // InternalOXtype.g:2736:2: ( ( ruleXForLoopExpression ) )
+ {
+ // InternalOXtype.g:2736:2: ( ( ruleXForLoopExpression ) )
+ // InternalOXtype.g:2737:3: ( ruleXForLoopExpression )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7());
+ }
+ // InternalOXtype.g:2738:3: ( ruleXForLoopExpression )
+ // InternalOXtype.g:2738:4: ruleXForLoopExpression
+ {
+ pushFollow(FOLLOW_2);
+ ruleXForLoopExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7());
+ }
+
+ }
+
+
+ }
+ break;
+ case 9 :
+ // InternalOXtype.g:2742:2: ( ruleXBasicForLoopExpression )
+ {
+ // InternalOXtype.g:2742:2: ( ruleXBasicForLoopExpression )
+ // InternalOXtype.g:2743:3: ruleXBasicForLoopExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXBasicForLoopExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8());
+ }
+
+ }
+
+
+ }
+ break;
+ case 10 :
+ // InternalOXtype.g:2748:2: ( ruleXWhileExpression )
+ {
+ // InternalOXtype.g:2748:2: ( ruleXWhileExpression )
+ // InternalOXtype.g:2749:3: ruleXWhileExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXWhileExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9());
+ }
+
+ }
+
+
+ }
+ break;
+ case 11 :
+ // InternalOXtype.g:2754:2: ( ruleXDoWhileExpression )
+ {
+ // InternalOXtype.g:2754:2: ( ruleXDoWhileExpression )
+ // InternalOXtype.g:2755:3: ruleXDoWhileExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXDoWhileExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10());
+ }
+
+ }
+
+
+ }
+ break;
+ case 12 :
+ // InternalOXtype.g:2760:2: ( ruleXThrowExpression )
+ {
+ // InternalOXtype.g:2760:2: ( ruleXThrowExpression )
+ // InternalOXtype.g:2761:3: ruleXThrowExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXThrowExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11());
+ }
+
+ }
+
+
+ }
+ break;
+ case 13 :
+ // InternalOXtype.g:2766:2: ( ruleXReturnExpression )
+ {
+ // InternalOXtype.g:2766:2: ( ruleXReturnExpression )
+ // InternalOXtype.g:2767:3: ruleXReturnExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXReturnExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12());
+ }
+
+ }
+
+
+ }
+ break;
+ case 14 :
+ // InternalOXtype.g:2772:2: ( ruleXTryCatchFinallyExpression )
+ {
+ // InternalOXtype.g:2772:2: ( ruleXTryCatchFinallyExpression )
+ // InternalOXtype.g:2773:3: ruleXTryCatchFinallyExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXTryCatchFinallyExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13());
+ }
+
+ }
+
+
+ }
+ break;
+ case 15 :
+ // InternalOXtype.g:2778:2: ( ruleXParenthesizedExpression )
+ {
+ // InternalOXtype.g:2778:2: ( ruleXParenthesizedExpression )
+ // InternalOXtype.g:2779:3: ruleXParenthesizedExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXParenthesizedExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XPrimaryExpression__Alternatives"
+
+
+ // $ANTLR start "rule__XLiteral__Alternatives"
+ // InternalOXtype.g:2788:1: rule__XLiteral__Alternatives : ( ( ruleXCollectionLiteral ) | ( ( ruleXClosure ) ) | ( ruleXBooleanLiteral ) | ( ruleXNumberLiteral ) | ( ruleXNullLiteral ) | ( ruleXStringLiteral ) | ( ruleXTypeLiteral ) );
+ public final void rule__XLiteral__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2792:1: ( ( ruleXCollectionLiteral ) | ( ( ruleXClosure ) ) | ( ruleXBooleanLiteral ) | ( ruleXNumberLiteral ) | ( ruleXNullLiteral ) | ( ruleXStringLiteral ) | ( ruleXTypeLiteral ) )
+ int alt26=7;
+ switch ( input.LA(1) ) {
+ case 57:
+ {
+ alt26=1;
+ }
+ break;
+ case 58:
+ {
+ alt26=2;
+ }
+ break;
+ case 50:
+ case 88:
+ {
+ alt26=3;
+ }
+ break;
+ case RULE_HEX:
+ case RULE_INT:
+ case RULE_DECIMAL:
+ {
+ alt26=4;
+ }
+ break;
+ case 73:
+ {
+ alt26=5;
+ }
+ break;
+ case RULE_STRING:
+ {
+ alt26=6;
+ }
+ break;
+ case 74:
+ {
+ alt26=7;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 26, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt26) {
+ case 1 :
+ // InternalOXtype.g:2793:2: ( ruleXCollectionLiteral )
+ {
+ // InternalOXtype.g:2793:2: ( ruleXCollectionLiteral )
+ // InternalOXtype.g:2794:3: ruleXCollectionLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXCollectionLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2799:2: ( ( ruleXClosure ) )
+ {
+ // InternalOXtype.g:2799:2: ( ( ruleXClosure ) )
+ // InternalOXtype.g:2800:3: ( ruleXClosure )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1());
+ }
+ // InternalOXtype.g:2801:3: ( ruleXClosure )
+ // InternalOXtype.g:2801:4: ruleXClosure
+ {
+ pushFollow(FOLLOW_2);
+ ruleXClosure();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:2805:2: ( ruleXBooleanLiteral )
+ {
+ // InternalOXtype.g:2805:2: ( ruleXBooleanLiteral )
+ // InternalOXtype.g:2806:3: ruleXBooleanLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXBooleanLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2());
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:2811:2: ( ruleXNumberLiteral )
+ {
+ // InternalOXtype.g:2811:2: ( ruleXNumberLiteral )
+ // InternalOXtype.g:2812:3: ruleXNumberLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXNumberLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3());
+ }
+
+ }
+
+
+ }
+ break;
+ case 5 :
+ // InternalOXtype.g:2817:2: ( ruleXNullLiteral )
+ {
+ // InternalOXtype.g:2817:2: ( ruleXNullLiteral )
+ // InternalOXtype.g:2818:3: ruleXNullLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXNullLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4());
+ }
+
+ }
+
+
+ }
+ break;
+ case 6 :
+ // InternalOXtype.g:2823:2: ( ruleXStringLiteral )
+ {
+ // InternalOXtype.g:2823:2: ( ruleXStringLiteral )
+ // InternalOXtype.g:2824:3: ruleXStringLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXStringLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5());
+ }
+
+ }
+
+
+ }
+ break;
+ case 7 :
+ // InternalOXtype.g:2829:2: ( ruleXTypeLiteral )
+ {
+ // InternalOXtype.g:2829:2: ( ruleXTypeLiteral )
+ // InternalOXtype.g:2830:3: ruleXTypeLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXTypeLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XLiteral__Alternatives"
+
+
+ // $ANTLR start "rule__XCollectionLiteral__Alternatives"
+ // InternalOXtype.g:2839:1: rule__XCollectionLiteral__Alternatives : ( ( ruleXSetLiteral ) | ( ruleXListLiteral ) );
+ public final void rule__XCollectionLiteral__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2843:1: ( ( ruleXSetLiteral ) | ( ruleXListLiteral ) )
+ int alt27=2;
+ int LA27_0 = input.LA(1);
+
+ if ( (LA27_0==57) ) {
+ int LA27_1 = input.LA(2);
+
+ if ( (LA27_1==61) ) {
+ alt27=1;
+ }
+ else if ( (LA27_1==58) ) {
+ alt27=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 27, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 27, 0, input);
+
+ throw nvae;
+ }
+ switch (alt27) {
+ case 1 :
+ // InternalOXtype.g:2844:2: ( ruleXSetLiteral )
+ {
+ // InternalOXtype.g:2844:2: ( ruleXSetLiteral )
+ // InternalOXtype.g:2845:3: ruleXSetLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXSetLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2850:2: ( ruleXListLiteral )
+ {
+ // InternalOXtype.g:2850:2: ( ruleXListLiteral )
+ // InternalOXtype.g:2851:3: ruleXListLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXListLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCollectionLiteral__Alternatives"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Alternatives_2"
+ // InternalOXtype.g:2860:1: rule__XSwitchExpression__Alternatives_2 : ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) | ( ( rule__XSwitchExpression__Group_2_1__0 ) ) );
+ public final void rule__XSwitchExpression__Alternatives_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2864:1: ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) | ( ( rule__XSwitchExpression__Group_2_1__0 ) ) )
+ int alt28=2;
+ alt28 = dfa28.predict(input);
+ switch (alt28) {
+ case 1 :
+ // InternalOXtype.g:2865:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) )
+ {
+ // InternalOXtype.g:2865:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) )
+ // InternalOXtype.g:2866:3: ( rule__XSwitchExpression__Group_2_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0());
+ }
+ // InternalOXtype.g:2867:3: ( rule__XSwitchExpression__Group_2_0__0 )
+ // InternalOXtype.g:2867:4: rule__XSwitchExpression__Group_2_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2871:2: ( ( rule__XSwitchExpression__Group_2_1__0 ) )
+ {
+ // InternalOXtype.g:2871:2: ( ( rule__XSwitchExpression__Group_2_1__0 ) )
+ // InternalOXtype.g:2872:3: ( rule__XSwitchExpression__Group_2_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1());
+ }
+ // InternalOXtype.g:2873:3: ( rule__XSwitchExpression__Group_2_1__0 )
+ // InternalOXtype.g:2873:4: rule__XSwitchExpression__Group_2_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Alternatives_2"
+
+
+ // $ANTLR start "rule__XCasePart__Alternatives_3"
+ // InternalOXtype.g:2881:1: rule__XCasePart__Alternatives_3 : ( ( ( rule__XCasePart__Group_3_0__0 ) ) | ( ( rule__XCasePart__FallThroughAssignment_3_1 ) ) );
+ public final void rule__XCasePart__Alternatives_3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2885:1: ( ( ( rule__XCasePart__Group_3_0__0 ) ) | ( ( rule__XCasePart__FallThroughAssignment_3_1 ) ) )
+ int alt29=2;
+ int LA29_0 = input.LA(1);
+
+ if ( (LA29_0==66) ) {
+ alt29=1;
+ }
+ else if ( (LA29_0==55) ) {
+ alt29=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 29, 0, input);
+
+ throw nvae;
+ }
+ switch (alt29) {
+ case 1 :
+ // InternalOXtype.g:2886:2: ( ( rule__XCasePart__Group_3_0__0 ) )
+ {
+ // InternalOXtype.g:2886:2: ( ( rule__XCasePart__Group_3_0__0 ) )
+ // InternalOXtype.g:2887:3: ( rule__XCasePart__Group_3_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCasePartAccess().getGroup_3_0());
+ }
+ // InternalOXtype.g:2888:3: ( rule__XCasePart__Group_3_0__0 )
+ // InternalOXtype.g:2888:4: rule__XCasePart__Group_3_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCasePart__Group_3_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCasePartAccess().getGroup_3_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2892:2: ( ( rule__XCasePart__FallThroughAssignment_3_1 ) )
+ {
+ // InternalOXtype.g:2892:2: ( ( rule__XCasePart__FallThroughAssignment_3_1 ) )
+ // InternalOXtype.g:2893:3: ( rule__XCasePart__FallThroughAssignment_3_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1());
+ }
+ // InternalOXtype.g:2894:3: ( rule__XCasePart__FallThroughAssignment_3_1 )
+ // InternalOXtype.g:2894:4: rule__XCasePart__FallThroughAssignment_3_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCasePart__FallThroughAssignment_3_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__Alternatives_3"
+
+
+ // $ANTLR start "rule__XExpressionOrVarDeclaration__Alternatives"
+ // InternalOXtype.g:2902:1: rule__XExpressionOrVarDeclaration__Alternatives : ( ( ruleXVariableDeclaration ) | ( ruleXExpression ) );
+ public final void rule__XExpressionOrVarDeclaration__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2906:1: ( ( ruleXVariableDeclaration ) | ( ruleXExpression ) )
+ int alt30=2;
+ int LA30_0 = input.LA(1);
+
+ if ( (LA30_0==44||LA30_0==87) ) {
+ alt30=1;
+ }
+ else if ( ((LA30_0>=RULE_ID && LA30_0<=RULE_STRING)||LA30_0==27||(LA30_0>=34 && LA30_0<=35)||LA30_0==40||(LA30_0>=45 && LA30_0<=50)||LA30_0==53||(LA30_0>=57 && LA30_0<=58)||LA30_0==61||LA30_0==63||LA30_0==65||(LA30_0>=69 && LA30_0<=77)||LA30_0==79||LA30_0==88) ) {
+ alt30=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 30, 0, input);
+
+ throw nvae;
+ }
+ switch (alt30) {
+ case 1 :
+ // InternalOXtype.g:2907:2: ( ruleXVariableDeclaration )
+ {
+ // InternalOXtype.g:2907:2: ( ruleXVariableDeclaration )
+ // InternalOXtype.g:2908:3: ruleXVariableDeclaration
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXVariableDeclaration();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2913:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:2913:2: ( ruleXExpression )
+ // InternalOXtype.g:2914:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XExpressionOrVarDeclaration__Alternatives"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Alternatives_1"
+ // InternalOXtype.g:2923:1: rule__XVariableDeclaration__Alternatives_1 : ( ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) ) | ( 'val' ) );
+ public final void rule__XVariableDeclaration__Alternatives_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2927:1: ( ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) ) | ( 'val' ) )
+ int alt31=2;
+ int LA31_0 = input.LA(1);
+
+ if ( (LA31_0==87) ) {
+ alt31=1;
+ }
+ else if ( (LA31_0==44) ) {
+ alt31=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 31, 0, input);
+
+ throw nvae;
+ }
+ switch (alt31) {
+ case 1 :
+ // InternalOXtype.g:2928:2: ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) )
+ {
+ // InternalOXtype.g:2928:2: ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) )
+ // InternalOXtype.g:2929:3: ( rule__XVariableDeclaration__WriteableAssignment_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0());
+ }
+ // InternalOXtype.g:2930:3: ( rule__XVariableDeclaration__WriteableAssignment_1_0 )
+ // InternalOXtype.g:2930:4: rule__XVariableDeclaration__WriteableAssignment_1_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__WriteableAssignment_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2934:2: ( 'val' )
+ {
+ // InternalOXtype.g:2934:2: ( 'val' )
+ // InternalOXtype.g:2935:3: 'val'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1());
+ }
+ match(input,44,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Alternatives_1"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Alternatives_2"
+ // InternalOXtype.g:2944:1: rule__XVariableDeclaration__Alternatives_2 : ( ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) | ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) ) );
+ public final void rule__XVariableDeclaration__Alternatives_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2948:1: ( ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) | ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) ) )
+ int alt32=2;
+ int LA32_0 = input.LA(1);
+
+ if ( (LA32_0==RULE_ID) ) {
+ int LA32_1 = input.LA(2);
+
+ if ( (synpred73_InternalOXtype()) ) {
+ alt32=1;
+ }
+ else if ( (true) ) {
+ alt32=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 32, 1, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA32_0==31||LA32_0==53) ) {
+ alt32=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 32, 0, input);
+
+ throw nvae;
+ }
+ switch (alt32) {
+ case 1 :
+ // InternalOXtype.g:2949:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) )
+ {
+ // InternalOXtype.g:2949:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) )
+ // InternalOXtype.g:2950:3: ( rule__XVariableDeclaration__Group_2_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0());
+ }
+ // InternalOXtype.g:2951:3: ( rule__XVariableDeclaration__Group_2_0__0 )
+ // InternalOXtype.g:2951:4: rule__XVariableDeclaration__Group_2_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__Group_2_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2955:2: ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) )
+ {
+ // InternalOXtype.g:2955:2: ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) )
+ // InternalOXtype.g:2956:3: ( rule__XVariableDeclaration__NameAssignment_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1());
+ }
+ // InternalOXtype.g:2957:3: ( rule__XVariableDeclaration__NameAssignment_2_1 )
+ // InternalOXtype.g:2957:4: rule__XVariableDeclaration__NameAssignment_2_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__NameAssignment_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Alternatives_2"
+
+
+ // $ANTLR start "rule__XFeatureCall__Alternatives_3_1"
+ // InternalOXtype.g:2965:1: rule__XFeatureCall__Alternatives_3_1 : ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) | ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) );
+ public final void rule__XFeatureCall__Alternatives_3_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2969:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) | ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) )
+ int alt33=2;
+ alt33 = dfa33.predict(input);
+ switch (alt33) {
+ case 1 :
+ // InternalOXtype.g:2970:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) )
+ {
+ // InternalOXtype.g:2970:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) )
+ // InternalOXtype.g:2971:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0());
+ }
+ // InternalOXtype.g:2972:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 )
+ // InternalOXtype.g:2972:4: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2976:2: ( ( rule__XFeatureCall__Group_3_1_1__0 ) )
+ {
+ // InternalOXtype.g:2976:2: ( ( rule__XFeatureCall__Group_3_1_1__0 ) )
+ // InternalOXtype.g:2977:3: ( rule__XFeatureCall__Group_3_1_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1());
+ }
+ // InternalOXtype.g:2978:3: ( rule__XFeatureCall__Group_3_1_1__0 )
+ // InternalOXtype.g:2978:4: rule__XFeatureCall__Group_3_1_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group_3_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Alternatives_3_1"
+
+
+ // $ANTLR start "rule__FeatureCallID__Alternatives"
+ // InternalOXtype.g:2986:1: rule__FeatureCallID__Alternatives : ( ( ruleValidID ) | ( 'extends' ) | ( 'static' ) | ( 'import' ) | ( 'extension' ) );
+ public final void rule__FeatureCallID__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:2990:1: ( ( ruleValidID ) | ( 'extends' ) | ( 'static' ) | ( 'import' ) | ( 'extension' ) )
+ int alt34=5;
+ switch ( input.LA(1) ) {
+ case RULE_ID:
+ {
+ alt34=1;
+ }
+ break;
+ case 45:
+ {
+ alt34=2;
+ }
+ break;
+ case 46:
+ {
+ alt34=3;
+ }
+ break;
+ case 47:
+ {
+ alt34=4;
+ }
+ break;
+ case 48:
+ {
+ alt34=5;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 34, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt34) {
+ case 1 :
+ // InternalOXtype.g:2991:2: ( ruleValidID )
+ {
+ // InternalOXtype.g:2991:2: ( ruleValidID )
+ // InternalOXtype.g:2992:3: ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2997:2: ( 'extends' )
+ {
+ // InternalOXtype.g:2997:2: ( 'extends' )
+ // InternalOXtype.g:2998:3: 'extends'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1());
+ }
+ match(input,45,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:3003:2: ( 'static' )
+ {
+ // InternalOXtype.g:3003:2: ( 'static' )
+ // InternalOXtype.g:3004:3: 'static'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2());
+ }
+ match(input,46,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2());
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:3009:2: ( 'import' )
+ {
+ // InternalOXtype.g:3009:2: ( 'import' )
+ // InternalOXtype.g:3010:3: 'import'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3());
+ }
+ match(input,47,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3());
+ }
+
+ }
+
+
+ }
+ break;
+ case 5 :
+ // InternalOXtype.g:3015:2: ( 'extension' )
+ {
+ // InternalOXtype.g:3015:2: ( 'extension' )
+ // InternalOXtype.g:3016:3: 'extension'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4());
+ }
+ match(input,48,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FeatureCallID__Alternatives"
+
+
+ // $ANTLR start "rule__IdOrSuper__Alternatives"
+ // InternalOXtype.g:3025:1: rule__IdOrSuper__Alternatives : ( ( ruleFeatureCallID ) | ( 'super' ) );
+ public final void rule__IdOrSuper__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3029:1: ( ( ruleFeatureCallID ) | ( 'super' ) )
+ int alt35=2;
+ int LA35_0 = input.LA(1);
+
+ if ( (LA35_0==RULE_ID||(LA35_0>=45 && LA35_0<=48)) ) {
+ alt35=1;
+ }
+ else if ( (LA35_0==49) ) {
+ alt35=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 35, 0, input);
+
+ throw nvae;
+ }
+ switch (alt35) {
+ case 1 :
+ // InternalOXtype.g:3030:2: ( ruleFeatureCallID )
+ {
+ // InternalOXtype.g:3030:2: ( ruleFeatureCallID )
+ // InternalOXtype.g:3031:3: ruleFeatureCallID
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleFeatureCallID();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:3036:2: ( 'super' )
+ {
+ // InternalOXtype.g:3036:2: ( 'super' )
+ // InternalOXtype.g:3037:3: 'super'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1());
+ }
+ match(input,49,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IdOrSuper__Alternatives"
+
+
+ // $ANTLR start "rule__XConstructorCall__Alternatives_4_1"
+ // InternalOXtype.g:3046:1: rule__XConstructorCall__Alternatives_4_1 : ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) | ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) );
+ public final void rule__XConstructorCall__Alternatives_4_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3050:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) | ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) )
+ int alt36=2;
+ alt36 = dfa36.predict(input);
+ switch (alt36) {
+ case 1 :
+ // InternalOXtype.g:3051:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) )
+ {
+ // InternalOXtype.g:3051:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) )
+ // InternalOXtype.g:3052:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0());
+ }
+ // InternalOXtype.g:3053:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 )
+ // InternalOXtype.g:3053:4: rule__XConstructorCall__ArgumentsAssignment_4_1_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__ArgumentsAssignment_4_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:3057:2: ( ( rule__XConstructorCall__Group_4_1_1__0 ) )
+ {
+ // InternalOXtype.g:3057:2: ( ( rule__XConstructorCall__Group_4_1_1__0 ) )
+ // InternalOXtype.g:3058:3: ( rule__XConstructorCall__Group_4_1_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1());
+ }
+ // InternalOXtype.g:3059:3: ( rule__XConstructorCall__Group_4_1_1__0 )
+ // InternalOXtype.g:3059:4: rule__XConstructorCall__Group_4_1_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_4_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Alternatives_4_1"
+
+
+ // $ANTLR start "rule__XBooleanLiteral__Alternatives_1"
+ // InternalOXtype.g:3067:1: rule__XBooleanLiteral__Alternatives_1 : ( ( 'false' ) | ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) ) );
+ public final void rule__XBooleanLiteral__Alternatives_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3071:1: ( ( 'false' ) | ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) ) )
+ int alt37=2;
+ int LA37_0 = input.LA(1);
+
+ if ( (LA37_0==50) ) {
+ alt37=1;
+ }
+ else if ( (LA37_0==88) ) {
+ alt37=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 37, 0, input);
+
+ throw nvae;
+ }
+ switch (alt37) {
+ case 1 :
+ // InternalOXtype.g:3072:2: ( 'false' )
+ {
+ // InternalOXtype.g:3072:2: ( 'false' )
+ // InternalOXtype.g:3073:3: 'false'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0());
+ }
+ match(input,50,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:3078:2: ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) )
+ {
+ // InternalOXtype.g:3078:2: ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) )
+ // InternalOXtype.g:3079:3: ( rule__XBooleanLiteral__IsTrueAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1());
+ }
+ // InternalOXtype.g:3080:3: ( rule__XBooleanLiteral__IsTrueAssignment_1_1 )
+ // InternalOXtype.g:3080:4: rule__XBooleanLiteral__IsTrueAssignment_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBooleanLiteral__IsTrueAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBooleanLiteral__Alternatives_1"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Alternatives_3"
+ // InternalOXtype.g:3088:1: rule__XTryCatchFinallyExpression__Alternatives_3 : ( ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) ) | ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) ) );
+ public final void rule__XTryCatchFinallyExpression__Alternatives_3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3092:1: ( ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) ) | ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) ) )
+ int alt38=2;
+ int LA38_0 = input.LA(1);
+
+ if ( (LA38_0==80) ) {
+ alt38=1;
+ }
+ else if ( (LA38_0==78) ) {
+ alt38=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 38, 0, input);
+
+ throw nvae;
+ }
+ switch (alt38) {
+ case 1 :
+ // InternalOXtype.g:3093:2: ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) )
+ {
+ // InternalOXtype.g:3093:2: ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) )
+ // InternalOXtype.g:3094:3: ( rule__XTryCatchFinallyExpression__Group_3_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0());
+ }
+ // InternalOXtype.g:3095:3: ( rule__XTryCatchFinallyExpression__Group_3_0__0 )
+ // InternalOXtype.g:3095:4: rule__XTryCatchFinallyExpression__Group_3_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__Group_3_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:3099:2: ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) )
+ {
+ // InternalOXtype.g:3099:2: ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) )
+ // InternalOXtype.g:3100:3: ( rule__XTryCatchFinallyExpression__Group_3_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1());
+ }
+ // InternalOXtype.g:3101:3: ( rule__XTryCatchFinallyExpression__Group_3_1__0 )
+ // InternalOXtype.g:3101:4: rule__XTryCatchFinallyExpression__Group_3_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__Group_3_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Alternatives_3"
+
+
+ // $ANTLR start "rule__Number__Alternatives"
+ // InternalOXtype.g:3109:1: rule__Number__Alternatives : ( ( RULE_HEX ) | ( ( rule__Number__Group_1__0 ) ) );
+ public final void rule__Number__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3113:1: ( ( RULE_HEX ) | ( ( rule__Number__Group_1__0 ) ) )
+ int alt39=2;
+ int LA39_0 = input.LA(1);
+
+ if ( (LA39_0==RULE_HEX) ) {
+ alt39=1;
+ }
+ else if ( ((LA39_0>=RULE_INT && LA39_0<=RULE_DECIMAL)) ) {
+ alt39=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 39, 0, input);
+
+ throw nvae;
+ }
+ switch (alt39) {
+ case 1 :
+ // InternalOXtype.g:3114:2: ( RULE_HEX )
+ {
+ // InternalOXtype.g:3114:2: ( RULE_HEX )
+ // InternalOXtype.g:3115:3: RULE_HEX
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0());
+ }
+ match(input,RULE_HEX,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:3120:2: ( ( rule__Number__Group_1__0 ) )
+ {
+ // InternalOXtype.g:3120:2: ( ( rule__Number__Group_1__0 ) )
+ // InternalOXtype.g:3121:3: ( rule__Number__Group_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNumberAccess().getGroup_1());
+ }
+ // InternalOXtype.g:3122:3: ( rule__Number__Group_1__0 )
+ // InternalOXtype.g:3122:4: rule__Number__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__Number__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNumberAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Number__Alternatives"
+
+
+ // $ANTLR start "rule__Number__Alternatives_1_0"
+ // InternalOXtype.g:3130:1: rule__Number__Alternatives_1_0 : ( ( RULE_INT ) | ( RULE_DECIMAL ) );
+ public final void rule__Number__Alternatives_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3134:1: ( ( RULE_INT ) | ( RULE_DECIMAL ) )
+ int alt40=2;
+ int LA40_0 = input.LA(1);
+
+ if ( (LA40_0==RULE_INT) ) {
+ alt40=1;
+ }
+ else if ( (LA40_0==RULE_DECIMAL) ) {
+ alt40=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 40, 0, input);
+
+ throw nvae;
+ }
+ switch (alt40) {
+ case 1 :
+ // InternalOXtype.g:3135:2: ( RULE_INT )
+ {
+ // InternalOXtype.g:3135:2: ( RULE_INT )
+ // InternalOXtype.g:3136:3: RULE_INT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0());
+ }
+ match(input,RULE_INT,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:3141:2: ( RULE_DECIMAL )
+ {
+ // InternalOXtype.g:3141:2: ( RULE_DECIMAL )
+ // InternalOXtype.g:3142:3: RULE_DECIMAL
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1());
+ }
+ match(input,RULE_DECIMAL,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Number__Alternatives_1_0"
+
+
+ // $ANTLR start "rule__Number__Alternatives_1_1_1"
+ // InternalOXtype.g:3151:1: rule__Number__Alternatives_1_1_1 : ( ( RULE_INT ) | ( RULE_DECIMAL ) );
+ public final void rule__Number__Alternatives_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3155:1: ( ( RULE_INT ) | ( RULE_DECIMAL ) )
+ int alt41=2;
+ int LA41_0 = input.LA(1);
+
+ if ( (LA41_0==RULE_INT) ) {
+ alt41=1;
+ }
+ else if ( (LA41_0==RULE_DECIMAL) ) {
+ alt41=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 41, 0, input);
+
+ throw nvae;
+ }
+ switch (alt41) {
+ case 1 :
+ // InternalOXtype.g:3156:2: ( RULE_INT )
+ {
+ // InternalOXtype.g:3156:2: ( RULE_INT )
+ // InternalOXtype.g:3157:3: RULE_INT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0());
+ }
+ match(input,RULE_INT,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:3162:2: ( RULE_DECIMAL )
+ {
+ // InternalOXtype.g:3162:2: ( RULE_DECIMAL )
+ // InternalOXtype.g:3163:3: RULE_DECIMAL
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1());
+ }
+ match(input,RULE_DECIMAL,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Number__Alternatives_1_1_1"
+
+
+ // $ANTLR start "rule__JvmTypeReference__Alternatives"
+ // InternalOXtype.g:3172:1: rule__JvmTypeReference__Alternatives : ( ( ( rule__JvmTypeReference__Group_0__0 ) ) | ( ruleXFunctionTypeRef ) );
+ public final void rule__JvmTypeReference__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3176:1: ( ( ( rule__JvmTypeReference__Group_0__0 ) ) | ( ruleXFunctionTypeRef ) )
+ int alt42=2;
+ int LA42_0 = input.LA(1);
+
+ if ( (LA42_0==RULE_ID) ) {
+ alt42=1;
+ }
+ else if ( (LA42_0==31||LA42_0==53) ) {
+ alt42=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 42, 0, input);
+
+ throw nvae;
+ }
+ switch (alt42) {
+ case 1 :
+ // InternalOXtype.g:3177:2: ( ( rule__JvmTypeReference__Group_0__0 ) )
+ {
+ // InternalOXtype.g:3177:2: ( ( rule__JvmTypeReference__Group_0__0 ) )
+ // InternalOXtype.g:3178:3: ( rule__JvmTypeReference__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0());
+ }
+ // InternalOXtype.g:3179:3: ( rule__JvmTypeReference__Group_0__0 )
+ // InternalOXtype.g:3179:4: rule__JvmTypeReference__Group_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmTypeReference__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:3183:2: ( ruleXFunctionTypeRef )
+ {
+ // InternalOXtype.g:3183:2: ( ruleXFunctionTypeRef )
+ // InternalOXtype.g:3184:3: ruleXFunctionTypeRef
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXFunctionTypeRef();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmTypeReference__Alternatives"
+
+
+ // $ANTLR start "rule__JvmArgumentTypeReference__Alternatives"
+ // InternalOXtype.g:3193:1: rule__JvmArgumentTypeReference__Alternatives : ( ( ruleJvmTypeReference ) | ( ruleJvmWildcardTypeReference ) );
+ public final void rule__JvmArgumentTypeReference__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3197:1: ( ( ruleJvmTypeReference ) | ( ruleJvmWildcardTypeReference ) )
+ int alt43=2;
+ int LA43_0 = input.LA(1);
+
+ if ( (LA43_0==RULE_ID||LA43_0==31||LA43_0==53) ) {
+ alt43=1;
+ }
+ else if ( (LA43_0==81) ) {
+ alt43=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 43, 0, input);
+
+ throw nvae;
+ }
+ switch (alt43) {
+ case 1 :
+ // InternalOXtype.g:3198:2: ( ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:3198:2: ( ruleJvmTypeReference )
+ // InternalOXtype.g:3199:3: ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:3204:2: ( ruleJvmWildcardTypeReference )
+ {
+ // InternalOXtype.g:3204:2: ( ruleJvmWildcardTypeReference )
+ // InternalOXtype.g:3205:3: ruleJvmWildcardTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmWildcardTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmArgumentTypeReference__Alternatives"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__Alternatives_2"
+ // InternalOXtype.g:3214:1: rule__JvmWildcardTypeReference__Alternatives_2 : ( ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) | ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) );
+ public final void rule__JvmWildcardTypeReference__Alternatives_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3218:1: ( ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) | ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) )
+ int alt44=2;
+ int LA44_0 = input.LA(1);
+
+ if ( (LA44_0==45) ) {
+ alt44=1;
+ }
+ else if ( (LA44_0==49) ) {
+ alt44=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 44, 0, input);
+
+ throw nvae;
+ }
+ switch (alt44) {
+ case 1 :
+ // InternalOXtype.g:3219:2: ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) )
+ {
+ // InternalOXtype.g:3219:2: ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) )
+ // InternalOXtype.g:3220:3: ( rule__JvmWildcardTypeReference__Group_2_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0());
+ }
+ // InternalOXtype.g:3221:3: ( rule__JvmWildcardTypeReference__Group_2_0__0 )
+ // InternalOXtype.g:3221:4: rule__JvmWildcardTypeReference__Group_2_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmWildcardTypeReference__Group_2_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:3225:2: ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) )
+ {
+ // InternalOXtype.g:3225:2: ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) )
+ // InternalOXtype.g:3226:3: ( rule__JvmWildcardTypeReference__Group_2_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1());
+ }
+ // InternalOXtype.g:3227:3: ( rule__JvmWildcardTypeReference__Group_2_1__0 )
+ // InternalOXtype.g:3227:4: rule__JvmWildcardTypeReference__Group_2_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmWildcardTypeReference__Group_2_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__Alternatives_2"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group__0"
+ // InternalOXtype.g:3235:1: rule__XImportDeclaration__Group__0 : rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1 ;
+ public final void rule__XImportDeclaration__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3239:1: ( rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1 )
+ // InternalOXtype.g:3240:2: rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1
+ {
+ pushFollow(FOLLOW_4);
+ rule__XImportDeclaration__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group__0"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group__0__Impl"
+ // InternalOXtype.g:3247:1: rule__XImportDeclaration__Group__0__Impl : ( () ) ;
+ public final void rule__XImportDeclaration__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3251:1: ( ( () ) )
+ // InternalOXtype.g:3252:1: ( () )
+ {
+ // InternalOXtype.g:3252:1: ( () )
+ // InternalOXtype.g:3253:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getOXImportDeclarationAction_0());
+ }
+ // InternalOXtype.g:3254:2: ()
+ // InternalOXtype.g:3254:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getOXImportDeclarationAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group__1"
+ // InternalOXtype.g:3262:1: rule__XImportDeclaration__Group__1 : rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2 ;
+ public final void rule__XImportDeclaration__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3266:1: ( rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2 )
+ // InternalOXtype.g:3267:2: rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2
+ {
+ pushFollow(FOLLOW_5);
+ rule__XImportDeclaration__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group__1"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group__1__Impl"
+ // InternalOXtype.g:3274:1: rule__XImportDeclaration__Group__1__Impl : ( 'import' ) ;
+ public final void rule__XImportDeclaration__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3278:1: ( ( 'import' ) )
+ // InternalOXtype.g:3279:1: ( 'import' )
+ {
+ // InternalOXtype.g:3279:1: ( 'import' )
+ // InternalOXtype.g:3280:2: 'import'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getImportKeyword_1());
+ }
+ match(input,47,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getImportKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group__2"
+ // InternalOXtype.g:3289:1: rule__XImportDeclaration__Group__2 : rule__XImportDeclaration__Group__2__Impl rule__XImportDeclaration__Group__3 ;
+ public final void rule__XImportDeclaration__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3293:1: ( rule__XImportDeclaration__Group__2__Impl rule__XImportDeclaration__Group__3 )
+ // InternalOXtype.g:3294:2: rule__XImportDeclaration__Group__2__Impl rule__XImportDeclaration__Group__3
+ {
+ pushFollow(FOLLOW_6);
+ rule__XImportDeclaration__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group__2"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group__2__Impl"
+ // InternalOXtype.g:3301:1: rule__XImportDeclaration__Group__2__Impl : ( ( rule__XImportDeclaration__Alternatives_2 ) ) ;
+ public final void rule__XImportDeclaration__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3305:1: ( ( ( rule__XImportDeclaration__Alternatives_2 ) ) )
+ // InternalOXtype.g:3306:1: ( ( rule__XImportDeclaration__Alternatives_2 ) )
+ {
+ // InternalOXtype.g:3306:1: ( ( rule__XImportDeclaration__Alternatives_2 ) )
+ // InternalOXtype.g:3307:2: ( rule__XImportDeclaration__Alternatives_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getAlternatives_2());
+ }
+ // InternalOXtype.g:3308:2: ( rule__XImportDeclaration__Alternatives_2 )
+ // InternalOXtype.g:3308:3: rule__XImportDeclaration__Alternatives_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__Alternatives_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getAlternatives_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group__3"
+ // InternalOXtype.g:3316:1: rule__XImportDeclaration__Group__3 : rule__XImportDeclaration__Group__3__Impl ;
+ public final void rule__XImportDeclaration__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3320:1: ( rule__XImportDeclaration__Group__3__Impl )
+ // InternalOXtype.g:3321:2: rule__XImportDeclaration__Group__3__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group__3"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group__3__Impl"
+ // InternalOXtype.g:3327:1: rule__XImportDeclaration__Group__3__Impl : ( ( ';' )? ) ;
+ public final void rule__XImportDeclaration__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3331:1: ( ( ( ';' )? ) )
+ // InternalOXtype.g:3332:1: ( ( ';' )? )
+ {
+ // InternalOXtype.g:3332:1: ( ( ';' )? )
+ // InternalOXtype.g:3333:2: ( ';' )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_3());
+ }
+ // InternalOXtype.g:3334:2: ( ';' )?
+ int alt45=2;
+ int LA45_0 = input.LA(1);
+
+ if ( (LA45_0==51) ) {
+ alt45=1;
+ }
+ switch (alt45) {
+ case 1 :
+ // InternalOXtype.g:3334:3: ';'
+ {
+ match(input,51,FOLLOW_2); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group_2_0__0"
+ // InternalOXtype.g:3343:1: rule__XImportDeclaration__Group_2_0__0 : rule__XImportDeclaration__Group_2_0__0__Impl rule__XImportDeclaration__Group_2_0__1 ;
+ public final void rule__XImportDeclaration__Group_2_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3347:1: ( rule__XImportDeclaration__Group_2_0__0__Impl rule__XImportDeclaration__Group_2_0__1 )
+ // InternalOXtype.g:3348:2: rule__XImportDeclaration__Group_2_0__0__Impl rule__XImportDeclaration__Group_2_0__1
+ {
+ pushFollow(FOLLOW_7);
+ rule__XImportDeclaration__Group_2_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__Group_2_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group_2_0__0"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group_2_0__0__Impl"
+ // InternalOXtype.g:3355:1: rule__XImportDeclaration__Group_2_0__0__Impl : ( ( rule__XImportDeclaration__StaticAssignment_2_0_0 ) ) ;
+ public final void rule__XImportDeclaration__Group_2_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3359:1: ( ( ( rule__XImportDeclaration__StaticAssignment_2_0_0 ) ) )
+ // InternalOXtype.g:3360:1: ( ( rule__XImportDeclaration__StaticAssignment_2_0_0 ) )
+ {
+ // InternalOXtype.g:3360:1: ( ( rule__XImportDeclaration__StaticAssignment_2_0_0 ) )
+ // InternalOXtype.g:3361:2: ( rule__XImportDeclaration__StaticAssignment_2_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_2_0_0());
+ }
+ // InternalOXtype.g:3362:2: ( rule__XImportDeclaration__StaticAssignment_2_0_0 )
+ // InternalOXtype.g:3362:3: rule__XImportDeclaration__StaticAssignment_2_0_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__StaticAssignment_2_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_2_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group_2_0__0__Impl"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group_2_0__1"
+ // InternalOXtype.g:3370:1: rule__XImportDeclaration__Group_2_0__1 : rule__XImportDeclaration__Group_2_0__1__Impl rule__XImportDeclaration__Group_2_0__2 ;
+ public final void rule__XImportDeclaration__Group_2_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3374:1: ( rule__XImportDeclaration__Group_2_0__1__Impl rule__XImportDeclaration__Group_2_0__2 )
+ // InternalOXtype.g:3375:2: rule__XImportDeclaration__Group_2_0__1__Impl rule__XImportDeclaration__Group_2_0__2
+ {
+ pushFollow(FOLLOW_7);
+ rule__XImportDeclaration__Group_2_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__Group_2_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group_2_0__1"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group_2_0__1__Impl"
+ // InternalOXtype.g:3382:1: rule__XImportDeclaration__Group_2_0__1__Impl : ( ( rule__XImportDeclaration__ExtensionAssignment_2_0_1 )? ) ;
+ public final void rule__XImportDeclaration__Group_2_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3386:1: ( ( ( rule__XImportDeclaration__ExtensionAssignment_2_0_1 )? ) )
+ // InternalOXtype.g:3387:1: ( ( rule__XImportDeclaration__ExtensionAssignment_2_0_1 )? )
+ {
+ // InternalOXtype.g:3387:1: ( ( rule__XImportDeclaration__ExtensionAssignment_2_0_1 )? )
+ // InternalOXtype.g:3388:2: ( rule__XImportDeclaration__ExtensionAssignment_2_0_1 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_2_0_1());
+ }
+ // InternalOXtype.g:3389:2: ( rule__XImportDeclaration__ExtensionAssignment_2_0_1 )?
+ int alt46=2;
+ int LA46_0 = input.LA(1);
+
+ if ( (LA46_0==48) ) {
+ alt46=1;
+ }
+ switch (alt46) {
+ case 1 :
+ // InternalOXtype.g:3389:3: rule__XImportDeclaration__ExtensionAssignment_2_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__ExtensionAssignment_2_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_2_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group_2_0__1__Impl"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group_2_0__2"
+ // InternalOXtype.g:3397:1: rule__XImportDeclaration__Group_2_0__2 : rule__XImportDeclaration__Group_2_0__2__Impl rule__XImportDeclaration__Group_2_0__3 ;
+ public final void rule__XImportDeclaration__Group_2_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3401:1: ( rule__XImportDeclaration__Group_2_0__2__Impl rule__XImportDeclaration__Group_2_0__3 )
+ // InternalOXtype.g:3402:2: rule__XImportDeclaration__Group_2_0__2__Impl rule__XImportDeclaration__Group_2_0__3
+ {
+ pushFollow(FOLLOW_8);
+ rule__XImportDeclaration__Group_2_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__Group_2_0__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group_2_0__2"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group_2_0__2__Impl"
+ // InternalOXtype.g:3409:1: rule__XImportDeclaration__Group_2_0__2__Impl : ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_0_2 ) ) ;
+ public final void rule__XImportDeclaration__Group_2_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3413:1: ( ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_0_2 ) ) )
+ // InternalOXtype.g:3414:1: ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_0_2 ) )
+ {
+ // InternalOXtype.g:3414:1: ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_0_2 ) )
+ // InternalOXtype.g:3415:2: ( rule__XImportDeclaration__ImportedTypeAssignment_2_0_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_0_2());
+ }
+ // InternalOXtype.g:3416:2: ( rule__XImportDeclaration__ImportedTypeAssignment_2_0_2 )
+ // InternalOXtype.g:3416:3: rule__XImportDeclaration__ImportedTypeAssignment_2_0_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__ImportedTypeAssignment_2_0_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group_2_0__2__Impl"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group_2_0__3"
+ // InternalOXtype.g:3424:1: rule__XImportDeclaration__Group_2_0__3 : rule__XImportDeclaration__Group_2_0__3__Impl ;
+ public final void rule__XImportDeclaration__Group_2_0__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3428:1: ( rule__XImportDeclaration__Group_2_0__3__Impl )
+ // InternalOXtype.g:3429:2: rule__XImportDeclaration__Group_2_0__3__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__Group_2_0__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group_2_0__3"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group_2_0__3__Impl"
+ // InternalOXtype.g:3435:1: rule__XImportDeclaration__Group_2_0__3__Impl : ( ( rule__XImportDeclaration__Alternatives_2_0_3 ) ) ;
+ public final void rule__XImportDeclaration__Group_2_0__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3439:1: ( ( ( rule__XImportDeclaration__Alternatives_2_0_3 ) ) )
+ // InternalOXtype.g:3440:1: ( ( rule__XImportDeclaration__Alternatives_2_0_3 ) )
+ {
+ // InternalOXtype.g:3440:1: ( ( rule__XImportDeclaration__Alternatives_2_0_3 ) )
+ // InternalOXtype.g:3441:2: ( rule__XImportDeclaration__Alternatives_2_0_3 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getAlternatives_2_0_3());
+ }
+ // InternalOXtype.g:3442:2: ( rule__XImportDeclaration__Alternatives_2_0_3 )
+ // InternalOXtype.g:3442:3: rule__XImportDeclaration__Alternatives_2_0_3
+ {
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__Alternatives_2_0_3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getAlternatives_2_0_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group_2_0__3__Impl"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group_2_3__0"
+ // InternalOXtype.g:3451:1: rule__XImportDeclaration__Group_2_3__0 : rule__XImportDeclaration__Group_2_3__0__Impl rule__XImportDeclaration__Group_2_3__1 ;
+ public final void rule__XImportDeclaration__Group_2_3__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3455:1: ( rule__XImportDeclaration__Group_2_3__0__Impl rule__XImportDeclaration__Group_2_3__1 )
+ // InternalOXtype.g:3456:2: rule__XImportDeclaration__Group_2_3__0__Impl rule__XImportDeclaration__Group_2_3__1
+ {
+ pushFollow(FOLLOW_9);
+ rule__XImportDeclaration__Group_2_3__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__Group_2_3__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group_2_3__0"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group_2_3__0__Impl"
+ // InternalOXtype.g:3463:1: rule__XImportDeclaration__Group_2_3__0__Impl : ( ( rule__XImportDeclaration__FqnImportAssignment_2_3_0 ) ) ;
+ public final void rule__XImportDeclaration__Group_2_3__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3467:1: ( ( ( rule__XImportDeclaration__FqnImportAssignment_2_3_0 ) ) )
+ // InternalOXtype.g:3468:1: ( ( rule__XImportDeclaration__FqnImportAssignment_2_3_0 ) )
+ {
+ // InternalOXtype.g:3468:1: ( ( rule__XImportDeclaration__FqnImportAssignment_2_3_0 ) )
+ // InternalOXtype.g:3469:2: ( rule__XImportDeclaration__FqnImportAssignment_2_3_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getFqnImportAssignment_2_3_0());
+ }
+ // InternalOXtype.g:3470:2: ( rule__XImportDeclaration__FqnImportAssignment_2_3_0 )
+ // InternalOXtype.g:3470:3: rule__XImportDeclaration__FqnImportAssignment_2_3_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__FqnImportAssignment_2_3_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getFqnImportAssignment_2_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group_2_3__0__Impl"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group_2_3__1"
+ // InternalOXtype.g:3478:1: rule__XImportDeclaration__Group_2_3__1 : rule__XImportDeclaration__Group_2_3__1__Impl ;
+ public final void rule__XImportDeclaration__Group_2_3__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3482:1: ( rule__XImportDeclaration__Group_2_3__1__Impl )
+ // InternalOXtype.g:3483:2: rule__XImportDeclaration__Group_2_3__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__Group_2_3__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group_2_3__1"
+
+
+ // $ANTLR start "rule__XImportDeclaration__Group_2_3__1__Impl"
+ // InternalOXtype.g:3489:1: rule__XImportDeclaration__Group_2_3__1__Impl : ( ( rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1 ) ) ;
+ public final void rule__XImportDeclaration__Group_2_3__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3493:1: ( ( ( rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1 ) ) )
+ // InternalOXtype.g:3494:1: ( ( rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1 ) )
+ {
+ // InternalOXtype.g:3494:1: ( ( rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1 ) )
+ // InternalOXtype.g:3495:2: ( rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameAssignment_2_3_1());
+ }
+ // InternalOXtype.g:3496:2: ( rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1 )
+ // InternalOXtype.g:3496:3: rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameAssignment_2_3_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__Group_2_3__1__Impl"
+
+
+ // $ANTLR start "rule__XAnnotation__Group__0"
+ // InternalOXtype.g:3505:1: rule__XAnnotation__Group__0 : rule__XAnnotation__Group__0__Impl rule__XAnnotation__Group__1 ;
+ public final void rule__XAnnotation__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3509:1: ( rule__XAnnotation__Group__0__Impl rule__XAnnotation__Group__1 )
+ // InternalOXtype.g:3510:2: rule__XAnnotation__Group__0__Impl rule__XAnnotation__Group__1
+ {
+ pushFollow(FOLLOW_10);
+ rule__XAnnotation__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group__0"
+
+
+ // $ANTLR start "rule__XAnnotation__Group__0__Impl"
+ // InternalOXtype.g:3517:1: rule__XAnnotation__Group__0__Impl : ( () ) ;
+ public final void rule__XAnnotation__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3521:1: ( ( () ) )
+ // InternalOXtype.g:3522:1: ( () )
+ {
+ // InternalOXtype.g:3522:1: ( () )
+ // InternalOXtype.g:3523:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getXAnnotationAction_0());
+ }
+ // InternalOXtype.g:3524:2: ()
+ // InternalOXtype.g:3524:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getXAnnotationAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotation__Group__1"
+ // InternalOXtype.g:3532:1: rule__XAnnotation__Group__1 : rule__XAnnotation__Group__1__Impl rule__XAnnotation__Group__2 ;
+ public final void rule__XAnnotation__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3536:1: ( rule__XAnnotation__Group__1__Impl rule__XAnnotation__Group__2 )
+ // InternalOXtype.g:3537:2: rule__XAnnotation__Group__1__Impl rule__XAnnotation__Group__2
+ {
+ pushFollow(FOLLOW_9);
+ rule__XAnnotation__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group__1"
+
+
+ // $ANTLR start "rule__XAnnotation__Group__1__Impl"
+ // InternalOXtype.g:3544:1: rule__XAnnotation__Group__1__Impl : ( '@' ) ;
+ public final void rule__XAnnotation__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3548:1: ( ( '@' ) )
+ // InternalOXtype.g:3549:1: ( '@' )
+ {
+ // InternalOXtype.g:3549:1: ( '@' )
+ // InternalOXtype.g:3550:2: '@'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getCommercialAtKeyword_1());
+ }
+ match(input,52,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getCommercialAtKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XAnnotation__Group__2"
+ // InternalOXtype.g:3559:1: rule__XAnnotation__Group__2 : rule__XAnnotation__Group__2__Impl rule__XAnnotation__Group__3 ;
+ public final void rule__XAnnotation__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3563:1: ( rule__XAnnotation__Group__2__Impl rule__XAnnotation__Group__3 )
+ // InternalOXtype.g:3564:2: rule__XAnnotation__Group__2__Impl rule__XAnnotation__Group__3
+ {
+ pushFollow(FOLLOW_11);
+ rule__XAnnotation__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group__2"
+
+
+ // $ANTLR start "rule__XAnnotation__Group__2__Impl"
+ // InternalOXtype.g:3571:1: rule__XAnnotation__Group__2__Impl : ( ( rule__XAnnotation__AnnotationTypeAssignment_2 ) ) ;
+ public final void rule__XAnnotation__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3575:1: ( ( ( rule__XAnnotation__AnnotationTypeAssignment_2 ) ) )
+ // InternalOXtype.g:3576:1: ( ( rule__XAnnotation__AnnotationTypeAssignment_2 ) )
+ {
+ // InternalOXtype.g:3576:1: ( ( rule__XAnnotation__AnnotationTypeAssignment_2 ) )
+ // InternalOXtype.g:3577:2: ( rule__XAnnotation__AnnotationTypeAssignment_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getAnnotationTypeAssignment_2());
+ }
+ // InternalOXtype.g:3578:2: ( rule__XAnnotation__AnnotationTypeAssignment_2 )
+ // InternalOXtype.g:3578:3: rule__XAnnotation__AnnotationTypeAssignment_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__AnnotationTypeAssignment_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getAnnotationTypeAssignment_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XAnnotation__Group__3"
+ // InternalOXtype.g:3586:1: rule__XAnnotation__Group__3 : rule__XAnnotation__Group__3__Impl ;
+ public final void rule__XAnnotation__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3590:1: ( rule__XAnnotation__Group__3__Impl )
+ // InternalOXtype.g:3591:2: rule__XAnnotation__Group__3__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group__3"
+
+
+ // $ANTLR start "rule__XAnnotation__Group__3__Impl"
+ // InternalOXtype.g:3597:1: rule__XAnnotation__Group__3__Impl : ( ( rule__XAnnotation__Group_3__0 )? ) ;
+ public final void rule__XAnnotation__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3601:1: ( ( ( rule__XAnnotation__Group_3__0 )? ) )
+ // InternalOXtype.g:3602:1: ( ( rule__XAnnotation__Group_3__0 )? )
+ {
+ // InternalOXtype.g:3602:1: ( ( rule__XAnnotation__Group_3__0 )? )
+ // InternalOXtype.g:3603:2: ( rule__XAnnotation__Group_3__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getGroup_3());
+ }
+ // InternalOXtype.g:3604:2: ( rule__XAnnotation__Group_3__0 )?
+ int alt47=2;
+ int LA47_0 = input.LA(1);
+
+ if ( (LA47_0==53) ) {
+ alt47=1;
+ }
+ switch (alt47) {
+ case 1 :
+ // InternalOXtype.g:3604:3: rule__XAnnotation__Group_3__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__Group_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getGroup_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XAnnotation__Group_3__0"
+ // InternalOXtype.g:3613:1: rule__XAnnotation__Group_3__0 : rule__XAnnotation__Group_3__0__Impl rule__XAnnotation__Group_3__1 ;
+ public final void rule__XAnnotation__Group_3__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3617:1: ( rule__XAnnotation__Group_3__0__Impl rule__XAnnotation__Group_3__1 )
+ // InternalOXtype.g:3618:2: rule__XAnnotation__Group_3__0__Impl rule__XAnnotation__Group_3__1
+ {
+ pushFollow(FOLLOW_12);
+ rule__XAnnotation__Group_3__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__Group_3__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group_3__0"
+
+
+ // $ANTLR start "rule__XAnnotation__Group_3__0__Impl"
+ // InternalOXtype.g:3625:1: rule__XAnnotation__Group_3__0__Impl : ( ( '(' ) ) ;
+ public final void rule__XAnnotation__Group_3__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3629:1: ( ( ( '(' ) ) )
+ // InternalOXtype.g:3630:1: ( ( '(' ) )
+ {
+ // InternalOXtype.g:3630:1: ( ( '(' ) )
+ // InternalOXtype.g:3631:2: ( '(' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getLeftParenthesisKeyword_3_0());
+ }
+ // InternalOXtype.g:3632:2: ( '(' )
+ // InternalOXtype.g:3632:3: '('
+ {
+ match(input,53,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getLeftParenthesisKeyword_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group_3__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotation__Group_3__1"
+ // InternalOXtype.g:3640:1: rule__XAnnotation__Group_3__1 : rule__XAnnotation__Group_3__1__Impl rule__XAnnotation__Group_3__2 ;
+ public final void rule__XAnnotation__Group_3__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3644:1: ( rule__XAnnotation__Group_3__1__Impl rule__XAnnotation__Group_3__2 )
+ // InternalOXtype.g:3645:2: rule__XAnnotation__Group_3__1__Impl rule__XAnnotation__Group_3__2
+ {
+ pushFollow(FOLLOW_12);
+ rule__XAnnotation__Group_3__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__Group_3__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group_3__1"
+
+
+ // $ANTLR start "rule__XAnnotation__Group_3__1__Impl"
+ // InternalOXtype.g:3652:1: rule__XAnnotation__Group_3__1__Impl : ( ( rule__XAnnotation__Alternatives_3_1 )? ) ;
+ public final void rule__XAnnotation__Group_3__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3656:1: ( ( ( rule__XAnnotation__Alternatives_3_1 )? ) )
+ // InternalOXtype.g:3657:1: ( ( rule__XAnnotation__Alternatives_3_1 )? )
+ {
+ // InternalOXtype.g:3657:1: ( ( rule__XAnnotation__Alternatives_3_1 )? )
+ // InternalOXtype.g:3658:2: ( rule__XAnnotation__Alternatives_3_1 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getAlternatives_3_1());
+ }
+ // InternalOXtype.g:3659:2: ( rule__XAnnotation__Alternatives_3_1 )?
+ int alt48=2;
+ int LA48_0 = input.LA(1);
+
+ if ( ((LA48_0>=RULE_ID && LA48_0<=RULE_STRING)||LA48_0==27||(LA48_0>=34 && LA48_0<=35)||LA48_0==40||(LA48_0>=45 && LA48_0<=50)||(LA48_0>=52 && LA48_0<=53)||(LA48_0>=57 && LA48_0<=58)||LA48_0==61||LA48_0==63||LA48_0==65||(LA48_0>=69 && LA48_0<=77)||LA48_0==79||LA48_0==88) ) {
+ alt48=1;
+ }
+ switch (alt48) {
+ case 1 :
+ // InternalOXtype.g:3659:3: rule__XAnnotation__Alternatives_3_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__Alternatives_3_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getAlternatives_3_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group_3__1__Impl"
+
+
+ // $ANTLR start "rule__XAnnotation__Group_3__2"
+ // InternalOXtype.g:3667:1: rule__XAnnotation__Group_3__2 : rule__XAnnotation__Group_3__2__Impl ;
+ public final void rule__XAnnotation__Group_3__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3671:1: ( rule__XAnnotation__Group_3__2__Impl )
+ // InternalOXtype.g:3672:2: rule__XAnnotation__Group_3__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__Group_3__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group_3__2"
+
+
+ // $ANTLR start "rule__XAnnotation__Group_3__2__Impl"
+ // InternalOXtype.g:3678:1: rule__XAnnotation__Group_3__2__Impl : ( ')' ) ;
+ public final void rule__XAnnotation__Group_3__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3682:1: ( ( ')' ) )
+ // InternalOXtype.g:3683:1: ( ')' )
+ {
+ // InternalOXtype.g:3683:1: ( ')' )
+ // InternalOXtype.g:3684:2: ')'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getRightParenthesisKeyword_3_2());
+ }
+ match(input,54,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getRightParenthesisKeyword_3_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group_3__2__Impl"
+
+
+ // $ANTLR start "rule__XAnnotation__Group_3_1_0__0"
+ // InternalOXtype.g:3694:1: rule__XAnnotation__Group_3_1_0__0 : rule__XAnnotation__Group_3_1_0__0__Impl rule__XAnnotation__Group_3_1_0__1 ;
+ public final void rule__XAnnotation__Group_3_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3698:1: ( rule__XAnnotation__Group_3_1_0__0__Impl rule__XAnnotation__Group_3_1_0__1 )
+ // InternalOXtype.g:3699:2: rule__XAnnotation__Group_3_1_0__0__Impl rule__XAnnotation__Group_3_1_0__1
+ {
+ pushFollow(FOLLOW_13);
+ rule__XAnnotation__Group_3_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__Group_3_1_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group_3_1_0__0"
+
+
+ // $ANTLR start "rule__XAnnotation__Group_3_1_0__0__Impl"
+ // InternalOXtype.g:3706:1: rule__XAnnotation__Group_3_1_0__0__Impl : ( ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0 ) ) ;
+ public final void rule__XAnnotation__Group_3_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3710:1: ( ( ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0 ) ) )
+ // InternalOXtype.g:3711:1: ( ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0 ) )
+ {
+ // InternalOXtype.g:3711:1: ( ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0 ) )
+ // InternalOXtype.g:3712:2: ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_0());
+ }
+ // InternalOXtype.g:3713:2: ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0 )
+ // InternalOXtype.g:3713:3: rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group_3_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotation__Group_3_1_0__1"
+ // InternalOXtype.g:3721:1: rule__XAnnotation__Group_3_1_0__1 : rule__XAnnotation__Group_3_1_0__1__Impl ;
+ public final void rule__XAnnotation__Group_3_1_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3725:1: ( rule__XAnnotation__Group_3_1_0__1__Impl )
+ // InternalOXtype.g:3726:2: rule__XAnnotation__Group_3_1_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__Group_3_1_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group_3_1_0__1"
+
+
+ // $ANTLR start "rule__XAnnotation__Group_3_1_0__1__Impl"
+ // InternalOXtype.g:3732:1: rule__XAnnotation__Group_3_1_0__1__Impl : ( ( rule__XAnnotation__Group_3_1_0_1__0 )* ) ;
+ public final void rule__XAnnotation__Group_3_1_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3736:1: ( ( ( rule__XAnnotation__Group_3_1_0_1__0 )* ) )
+ // InternalOXtype.g:3737:1: ( ( rule__XAnnotation__Group_3_1_0_1__0 )* )
+ {
+ // InternalOXtype.g:3737:1: ( ( rule__XAnnotation__Group_3_1_0_1__0 )* )
+ // InternalOXtype.g:3738:2: ( rule__XAnnotation__Group_3_1_0_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getGroup_3_1_0_1());
+ }
+ // InternalOXtype.g:3739:2: ( rule__XAnnotation__Group_3_1_0_1__0 )*
+ loop49:
+ do {
+ int alt49=2;
+ int LA49_0 = input.LA(1);
+
+ if ( (LA49_0==55) ) {
+ alt49=1;
+ }
+
+
+ switch (alt49) {
+ case 1 :
+ // InternalOXtype.g:3739:3: rule__XAnnotation__Group_3_1_0_1__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XAnnotation__Group_3_1_0_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop49;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getGroup_3_1_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group_3_1_0__1__Impl"
+
+
+ // $ANTLR start "rule__XAnnotation__Group_3_1_0_1__0"
+ // InternalOXtype.g:3748:1: rule__XAnnotation__Group_3_1_0_1__0 : rule__XAnnotation__Group_3_1_0_1__0__Impl rule__XAnnotation__Group_3_1_0_1__1 ;
+ public final void rule__XAnnotation__Group_3_1_0_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3752:1: ( rule__XAnnotation__Group_3_1_0_1__0__Impl rule__XAnnotation__Group_3_1_0_1__1 )
+ // InternalOXtype.g:3753:2: rule__XAnnotation__Group_3_1_0_1__0__Impl rule__XAnnotation__Group_3_1_0_1__1
+ {
+ pushFollow(FOLLOW_9);
+ rule__XAnnotation__Group_3_1_0_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__Group_3_1_0_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group_3_1_0_1__0"
+
+
+ // $ANTLR start "rule__XAnnotation__Group_3_1_0_1__0__Impl"
+ // InternalOXtype.g:3760:1: rule__XAnnotation__Group_3_1_0_1__0__Impl : ( ',' ) ;
+ public final void rule__XAnnotation__Group_3_1_0_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3764:1: ( ( ',' ) )
+ // InternalOXtype.g:3765:1: ( ',' )
+ {
+ // InternalOXtype.g:3765:1: ( ',' )
+ // InternalOXtype.g:3766:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getCommaKeyword_3_1_0_1_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getCommaKeyword_3_1_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group_3_1_0_1__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotation__Group_3_1_0_1__1"
+ // InternalOXtype.g:3775:1: rule__XAnnotation__Group_3_1_0_1__1 : rule__XAnnotation__Group_3_1_0_1__1__Impl ;
+ public final void rule__XAnnotation__Group_3_1_0_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3779:1: ( rule__XAnnotation__Group_3_1_0_1__1__Impl )
+ // InternalOXtype.g:3780:2: rule__XAnnotation__Group_3_1_0_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__Group_3_1_0_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group_3_1_0_1__1"
+
+
+ // $ANTLR start "rule__XAnnotation__Group_3_1_0_1__1__Impl"
+ // InternalOXtype.g:3786:1: rule__XAnnotation__Group_3_1_0_1__1__Impl : ( ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1 ) ) ;
+ public final void rule__XAnnotation__Group_3_1_0_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3790:1: ( ( ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1 ) ) )
+ // InternalOXtype.g:3791:1: ( ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1 ) )
+ {
+ // InternalOXtype.g:3791:1: ( ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1 ) )
+ // InternalOXtype.g:3792:2: ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_1_1());
+ }
+ // InternalOXtype.g:3793:2: ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1 )
+ // InternalOXtype.g:3793:3: rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__Group_3_1_0_1__1__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValuePair__Group__0"
+ // InternalOXtype.g:3802:1: rule__XAnnotationElementValuePair__Group__0 : rule__XAnnotationElementValuePair__Group__0__Impl rule__XAnnotationElementValuePair__Group__1 ;
+ public final void rule__XAnnotationElementValuePair__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3806:1: ( rule__XAnnotationElementValuePair__Group__0__Impl rule__XAnnotationElementValuePair__Group__1 )
+ // InternalOXtype.g:3807:2: rule__XAnnotationElementValuePair__Group__0__Impl rule__XAnnotationElementValuePair__Group__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XAnnotationElementValuePair__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValuePair__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValuePair__Group__0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValuePair__Group__0__Impl"
+ // InternalOXtype.g:3814:1: rule__XAnnotationElementValuePair__Group__0__Impl : ( ( rule__XAnnotationElementValuePair__Group_0__0 ) ) ;
+ public final void rule__XAnnotationElementValuePair__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3818:1: ( ( ( rule__XAnnotationElementValuePair__Group_0__0 ) ) )
+ // InternalOXtype.g:3819:1: ( ( rule__XAnnotationElementValuePair__Group_0__0 ) )
+ {
+ // InternalOXtype.g:3819:1: ( ( rule__XAnnotationElementValuePair__Group_0__0 ) )
+ // InternalOXtype.g:3820:2: ( rule__XAnnotationElementValuePair__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0());
+ }
+ // InternalOXtype.g:3821:2: ( rule__XAnnotationElementValuePair__Group_0__0 )
+ // InternalOXtype.g:3821:3: rule__XAnnotationElementValuePair__Group_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValuePair__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValuePair__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValuePair__Group__1"
+ // InternalOXtype.g:3829:1: rule__XAnnotationElementValuePair__Group__1 : rule__XAnnotationElementValuePair__Group__1__Impl ;
+ public final void rule__XAnnotationElementValuePair__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3833:1: ( rule__XAnnotationElementValuePair__Group__1__Impl )
+ // InternalOXtype.g:3834:2: rule__XAnnotationElementValuePair__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValuePair__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValuePair__Group__1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValuePair__Group__1__Impl"
+ // InternalOXtype.g:3840:1: rule__XAnnotationElementValuePair__Group__1__Impl : ( ( rule__XAnnotationElementValuePair__ValueAssignment_1 ) ) ;
+ public final void rule__XAnnotationElementValuePair__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3844:1: ( ( ( rule__XAnnotationElementValuePair__ValueAssignment_1 ) ) )
+ // InternalOXtype.g:3845:1: ( ( rule__XAnnotationElementValuePair__ValueAssignment_1 ) )
+ {
+ // InternalOXtype.g:3845:1: ( ( rule__XAnnotationElementValuePair__ValueAssignment_1 ) )
+ // InternalOXtype.g:3846:2: ( rule__XAnnotationElementValuePair__ValueAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValuePairAccess().getValueAssignment_1());
+ }
+ // InternalOXtype.g:3847:2: ( rule__XAnnotationElementValuePair__ValueAssignment_1 )
+ // InternalOXtype.g:3847:3: rule__XAnnotationElementValuePair__ValueAssignment_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValuePair__ValueAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValuePairAccess().getValueAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValuePair__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValuePair__Group_0__0"
+ // InternalOXtype.g:3856:1: rule__XAnnotationElementValuePair__Group_0__0 : rule__XAnnotationElementValuePair__Group_0__0__Impl ;
+ public final void rule__XAnnotationElementValuePair__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3860:1: ( rule__XAnnotationElementValuePair__Group_0__0__Impl )
+ // InternalOXtype.g:3861:2: rule__XAnnotationElementValuePair__Group_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValuePair__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValuePair__Group_0__0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValuePair__Group_0__0__Impl"
+ // InternalOXtype.g:3867:1: rule__XAnnotationElementValuePair__Group_0__0__Impl : ( ( rule__XAnnotationElementValuePair__Group_0_0__0 ) ) ;
+ public final void rule__XAnnotationElementValuePair__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3871:1: ( ( ( rule__XAnnotationElementValuePair__Group_0_0__0 ) ) )
+ // InternalOXtype.g:3872:1: ( ( rule__XAnnotationElementValuePair__Group_0_0__0 ) )
+ {
+ // InternalOXtype.g:3872:1: ( ( rule__XAnnotationElementValuePair__Group_0_0__0 ) )
+ // InternalOXtype.g:3873:2: ( rule__XAnnotationElementValuePair__Group_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0_0());
+ }
+ // InternalOXtype.g:3874:2: ( rule__XAnnotationElementValuePair__Group_0_0__0 )
+ // InternalOXtype.g:3874:3: rule__XAnnotationElementValuePair__Group_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValuePair__Group_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValuePair__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValuePair__Group_0_0__0"
+ // InternalOXtype.g:3883:1: rule__XAnnotationElementValuePair__Group_0_0__0 : rule__XAnnotationElementValuePair__Group_0_0__0__Impl rule__XAnnotationElementValuePair__Group_0_0__1 ;
+ public final void rule__XAnnotationElementValuePair__Group_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3887:1: ( rule__XAnnotationElementValuePair__Group_0_0__0__Impl rule__XAnnotationElementValuePair__Group_0_0__1 )
+ // InternalOXtype.g:3888:2: rule__XAnnotationElementValuePair__Group_0_0__0__Impl rule__XAnnotationElementValuePair__Group_0_0__1
+ {
+ pushFollow(FOLLOW_16);
+ rule__XAnnotationElementValuePair__Group_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValuePair__Group_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValuePair__Group_0_0__0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValuePair__Group_0_0__0__Impl"
+ // InternalOXtype.g:3895:1: rule__XAnnotationElementValuePair__Group_0_0__0__Impl : ( ( rule__XAnnotationElementValuePair__ElementAssignment_0_0_0 ) ) ;
+ public final void rule__XAnnotationElementValuePair__Group_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3899:1: ( ( ( rule__XAnnotationElementValuePair__ElementAssignment_0_0_0 ) ) )
+ // InternalOXtype.g:3900:1: ( ( rule__XAnnotationElementValuePair__ElementAssignment_0_0_0 ) )
+ {
+ // InternalOXtype.g:3900:1: ( ( rule__XAnnotationElementValuePair__ElementAssignment_0_0_0 ) )
+ // InternalOXtype.g:3901:2: ( rule__XAnnotationElementValuePair__ElementAssignment_0_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValuePairAccess().getElementAssignment_0_0_0());
+ }
+ // InternalOXtype.g:3902:2: ( rule__XAnnotationElementValuePair__ElementAssignment_0_0_0 )
+ // InternalOXtype.g:3902:3: rule__XAnnotationElementValuePair__ElementAssignment_0_0_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValuePair__ElementAssignment_0_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValuePairAccess().getElementAssignment_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValuePair__Group_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValuePair__Group_0_0__1"
+ // InternalOXtype.g:3910:1: rule__XAnnotationElementValuePair__Group_0_0__1 : rule__XAnnotationElementValuePair__Group_0_0__1__Impl ;
+ public final void rule__XAnnotationElementValuePair__Group_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3914:1: ( rule__XAnnotationElementValuePair__Group_0_0__1__Impl )
+ // InternalOXtype.g:3915:2: rule__XAnnotationElementValuePair__Group_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValuePair__Group_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValuePair__Group_0_0__1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValuePair__Group_0_0__1__Impl"
+ // InternalOXtype.g:3921:1: rule__XAnnotationElementValuePair__Group_0_0__1__Impl : ( '=' ) ;
+ public final void rule__XAnnotationElementValuePair__Group_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3925:1: ( ( '=' ) )
+ // InternalOXtype.g:3926:1: ( '=' )
+ {
+ // InternalOXtype.g:3926:1: ( '=' )
+ // InternalOXtype.g:3927:2: '='
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValuePairAccess().getEqualsSignKeyword_0_0_1());
+ }
+ match(input,13,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValuePairAccess().getEqualsSignKeyword_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValuePair__Group_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0__0"
+ // InternalOXtype.g:3937:1: rule__XAnnotationElementValueOrCommaList__Group_0__0 : rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0__1 ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3941:1: ( rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0__1 )
+ // InternalOXtype.g:3942:2: rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0__1
+ {
+ pushFollow(FOLLOW_17);
+ rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0__0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl"
+ // InternalOXtype.g:3949:1: rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl : ( ( rule__XAnnotationElementValueOrCommaList__Group_0_0__0 ) ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3953:1: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_0_0__0 ) ) )
+ // InternalOXtype.g:3954:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0_0__0 ) )
+ {
+ // InternalOXtype.g:3954:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0_0__0 ) )
+ // InternalOXtype.g:3955:2: ( rule__XAnnotationElementValueOrCommaList__Group_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0());
+ }
+ // InternalOXtype.g:3956:2: ( rule__XAnnotationElementValueOrCommaList__Group_0_0__0 )
+ // InternalOXtype.g:3956:3: rule__XAnnotationElementValueOrCommaList__Group_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0__1"
+ // InternalOXtype.g:3964:1: rule__XAnnotationElementValueOrCommaList__Group_0__1 : rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl rule__XAnnotationElementValueOrCommaList__Group_0__2 ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3968:1: ( rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl rule__XAnnotationElementValueOrCommaList__Group_0__2 )
+ // InternalOXtype.g:3969:2: rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl rule__XAnnotationElementValueOrCommaList__Group_0__2
+ {
+ pushFollow(FOLLOW_17);
+ rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0__1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl"
+ // InternalOXtype.g:3976:1: rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl : ( ( rule__XAnnotationElementValueOrCommaList__Group_0_1__0 )? ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3980:1: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_0_1__0 )? ) )
+ // InternalOXtype.g:3981:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0_1__0 )? )
+ {
+ // InternalOXtype.g:3981:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0_1__0 )? )
+ // InternalOXtype.g:3982:2: ( rule__XAnnotationElementValueOrCommaList__Group_0_1__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1());
+ }
+ // InternalOXtype.g:3983:2: ( rule__XAnnotationElementValueOrCommaList__Group_0_1__0 )?
+ int alt50=2;
+ int LA50_0 = input.LA(1);
+
+ if ( ((LA50_0>=RULE_ID && LA50_0<=RULE_STRING)||LA50_0==27||(LA50_0>=34 && LA50_0<=35)||LA50_0==40||(LA50_0>=45 && LA50_0<=50)||(LA50_0>=52 && LA50_0<=53)||(LA50_0>=57 && LA50_0<=58)||LA50_0==61||LA50_0==63||LA50_0==65||(LA50_0>=69 && LA50_0<=77)||LA50_0==79||LA50_0==88) ) {
+ alt50=1;
+ }
+ switch (alt50) {
+ case 1 :
+ // InternalOXtype.g:3983:3: rule__XAnnotationElementValueOrCommaList__Group_0_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_0_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0__2"
+ // InternalOXtype.g:3991:1: rule__XAnnotationElementValueOrCommaList__Group_0__2 : rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:3995:1: ( rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl )
+ // InternalOXtype.g:3996:2: rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0__2"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl"
+ // InternalOXtype.g:4002:1: rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl : ( ']' ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4006:1: ( ( ']' ) )
+ // InternalOXtype.g:4007:1: ( ']' )
+ {
+ // InternalOXtype.g:4007:1: ( ']' )
+ // InternalOXtype.g:4008:2: ']'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getRightSquareBracketKeyword_0_2());
+ }
+ match(input,56,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getRightSquareBracketKeyword_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_0__0"
+ // InternalOXtype.g:4018:1: rule__XAnnotationElementValueOrCommaList__Group_0_0__0 : rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4022:1: ( rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl )
+ // InternalOXtype.g:4023:2: rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_0__0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl"
+ // InternalOXtype.g:4029:1: rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl : ( ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0 ) ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4033:1: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0 ) ) )
+ // InternalOXtype.g:4034:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0 ) )
+ {
+ // InternalOXtype.g:4034:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0 ) )
+ // InternalOXtype.g:4035:2: ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0_0());
+ }
+ // InternalOXtype.g:4036:2: ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0 )
+ // InternalOXtype.g:4036:3: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0"
+ // InternalOXtype.g:4045:1: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0 : rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1 ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4049:1: ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1 )
+ // InternalOXtype.g:4050:2: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1
+ {
+ pushFollow(FOLLOW_18);
+ rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl"
+ // InternalOXtype.g:4057:1: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl : ( () ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4061:1: ( ( () ) )
+ // InternalOXtype.g:4062:1: ( () )
+ {
+ // InternalOXtype.g:4062:1: ( () )
+ // InternalOXtype.g:4063:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralAction_0_0_0_0());
+ }
+ // InternalOXtype.g:4064:2: ()
+ // InternalOXtype.g:4064:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralAction_0_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1"
+ // InternalOXtype.g:4072:1: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1 : rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2 ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4076:1: ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2 )
+ // InternalOXtype.g:4077:2: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2
+ {
+ pushFollow(FOLLOW_19);
+ rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl"
+ // InternalOXtype.g:4084:1: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl : ( '#' ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4088:1: ( ( '#' ) )
+ // InternalOXtype.g:4089:1: ( '#' )
+ {
+ // InternalOXtype.g:4089:1: ( '#' )
+ // InternalOXtype.g:4090:2: '#'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getNumberSignKeyword_0_0_0_1());
+ }
+ match(input,57,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getNumberSignKeyword_0_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2"
+ // InternalOXtype.g:4099:1: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2 : rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4103:1: ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl )
+ // InternalOXtype.g:4104:2: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl"
+ // InternalOXtype.g:4110:1: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl : ( '[' ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4114:1: ( ( '[' ) )
+ // InternalOXtype.g:4115:1: ( '[' )
+ {
+ // InternalOXtype.g:4115:1: ( '[' )
+ // InternalOXtype.g:4116:2: '['
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getLeftSquareBracketKeyword_0_0_0_2());
+ }
+ match(input,58,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getLeftSquareBracketKeyword_0_0_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_1__0"
+ // InternalOXtype.g:4126:1: rule__XAnnotationElementValueOrCommaList__Group_0_1__0 : rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_1__1 ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4130:1: ( rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_1__1 )
+ // InternalOXtype.g:4131:2: rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_1__1
+ {
+ pushFollow(FOLLOW_13);
+ rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_0_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_1__0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl"
+ // InternalOXtype.g:4138:1: rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl : ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0 ) ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4142:1: ( ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0 ) ) )
+ // InternalOXtype.g:4143:1: ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0 ) )
+ {
+ // InternalOXtype.g:4143:1: ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0 ) )
+ // InternalOXtype.g:4144:2: ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_0());
+ }
+ // InternalOXtype.g:4145:2: ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0 )
+ // InternalOXtype.g:4145:3: rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_1__1"
+ // InternalOXtype.g:4153:1: rule__XAnnotationElementValueOrCommaList__Group_0_1__1 : rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4157:1: ( rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl )
+ // InternalOXtype.g:4158:2: rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_1__1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl"
+ // InternalOXtype.g:4164:1: rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl : ( ( rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0 )* ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4168:1: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0 )* ) )
+ // InternalOXtype.g:4169:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0 )* )
+ {
+ // InternalOXtype.g:4169:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0 )* )
+ // InternalOXtype.g:4170:2: ( rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1_1());
+ }
+ // InternalOXtype.g:4171:2: ( rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0 )*
+ loop51:
+ do {
+ int alt51=2;
+ int LA51_0 = input.LA(1);
+
+ if ( (LA51_0==55) ) {
+ alt51=1;
+ }
+
+
+ switch (alt51) {
+ case 1 :
+ // InternalOXtype.g:4171:3: rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop51;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0"
+ // InternalOXtype.g:4180:1: rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0 : rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1 ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4184:1: ( rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1 )
+ // InternalOXtype.g:4185:2: rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl"
+ // InternalOXtype.g:4192:1: rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl : ( ',' ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4196:1: ( ( ',' ) )
+ // InternalOXtype.g:4197:1: ( ',' )
+ {
+ // InternalOXtype.g:4197:1: ( ',' )
+ // InternalOXtype.g:4198:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_0_1_1_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_0_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1"
+ // InternalOXtype.g:4207:1: rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1 : rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4211:1: ( rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl )
+ // InternalOXtype.g:4212:2: rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl"
+ // InternalOXtype.g:4218:1: rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl : ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1 ) ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4222:1: ( ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1 ) ) )
+ // InternalOXtype.g:4223:1: ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1 ) )
+ {
+ // InternalOXtype.g:4223:1: ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1 ) )
+ // InternalOXtype.g:4224:2: ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_1_1());
+ }
+ // InternalOXtype.g:4225:2: ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1 )
+ // InternalOXtype.g:4225:3: rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1__0"
+ // InternalOXtype.g:4234:1: rule__XAnnotationElementValueOrCommaList__Group_1__0 : rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1__1 ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4238:1: ( rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1__1 )
+ // InternalOXtype.g:4239:2: rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1__1
+ {
+ pushFollow(FOLLOW_13);
+ rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1__0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl"
+ // InternalOXtype.g:4246:1: rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl : ( ruleXAnnotationOrExpression ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4250:1: ( ( ruleXAnnotationOrExpression ) )
+ // InternalOXtype.g:4251:1: ( ruleXAnnotationOrExpression )
+ {
+ // InternalOXtype.g:4251:1: ( ruleXAnnotationOrExpression )
+ // InternalOXtype.g:4252:2: ruleXAnnotationOrExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXAnnotationOrExpressionParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAnnotationOrExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXAnnotationOrExpressionParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1__1"
+ // InternalOXtype.g:4261:1: rule__XAnnotationElementValueOrCommaList__Group_1__1 : rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4265:1: ( rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl )
+ // InternalOXtype.g:4266:2: rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1__1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl"
+ // InternalOXtype.g:4272:1: rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl : ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1__0 )? ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4276:1: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1__0 )? ) )
+ // InternalOXtype.g:4277:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1__0 )? )
+ {
+ // InternalOXtype.g:4277:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1__0 )? )
+ // InternalOXtype.g:4278:2: ( rule__XAnnotationElementValueOrCommaList__Group_1_1__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1());
+ }
+ // InternalOXtype.g:4279:2: ( rule__XAnnotationElementValueOrCommaList__Group_1_1__0 )?
+ int alt52=2;
+ int LA52_0 = input.LA(1);
+
+ if ( (LA52_0==55) ) {
+ alt52=1;
+ }
+ switch (alt52) {
+ case 1 :
+ // InternalOXtype.g:4279:3: rule__XAnnotationElementValueOrCommaList__Group_1_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1_1__0"
+ // InternalOXtype.g:4288:1: rule__XAnnotationElementValueOrCommaList__Group_1_1__0 : rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1_1__1 ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4292:1: ( rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1_1__1 )
+ // InternalOXtype.g:4293:2: rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1_1__1
+ {
+ pushFollow(FOLLOW_13);
+ rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1_1__0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl"
+ // InternalOXtype.g:4300:1: rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl : ( () ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4304:1: ( ( () ) )
+ // InternalOXtype.g:4305:1: ( () )
+ {
+ // InternalOXtype.g:4305:1: ( () )
+ // InternalOXtype.g:4306:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0());
+ }
+ // InternalOXtype.g:4307:2: ()
+ // InternalOXtype.g:4307:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1_1__1"
+ // InternalOXtype.g:4315:1: rule__XAnnotationElementValueOrCommaList__Group_1_1__1 : rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4319:1: ( rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl )
+ // InternalOXtype.g:4320:2: rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1_1__1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl"
+ // InternalOXtype.g:4326:1: rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl : ( ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 ) ) ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )* ) ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4330:1: ( ( ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 ) ) ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )* ) ) )
+ // InternalOXtype.g:4331:1: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 ) ) ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )* ) )
+ {
+ // InternalOXtype.g:4331:1: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 ) ) ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )* ) )
+ // InternalOXtype.g:4332:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 ) ) ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )* )
+ {
+ // InternalOXtype.g:4332:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 ) )
+ // InternalOXtype.g:4333:3: ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1());
+ }
+ // InternalOXtype.g:4334:3: ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )
+ // InternalOXtype.g:4334:4: rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1());
+ }
+
+ }
+
+ // InternalOXtype.g:4337:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )* )
+ // InternalOXtype.g:4338:3: ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1());
+ }
+ // InternalOXtype.g:4339:3: ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )*
+ loop53:
+ do {
+ int alt53=2;
+ int LA53_0 = input.LA(1);
+
+ if ( (LA53_0==55) ) {
+ alt53=1;
+ }
+
+
+ switch (alt53) {
+ case 1 :
+ // InternalOXtype.g:4339:4: rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop53;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1());
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0"
+ // InternalOXtype.g:4349:1: rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 : rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1 ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4353:1: ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1 )
+ // InternalOXtype.g:4354:2: rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl"
+ // InternalOXtype.g:4361:1: rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl : ( ',' ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4365:1: ( ( ',' ) )
+ // InternalOXtype.g:4366:1: ( ',' )
+ {
+ // InternalOXtype.g:4366:1: ( ',' )
+ // InternalOXtype.g:4367:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_1_1_1_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1"
+ // InternalOXtype.g:4376:1: rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1 : rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4380:1: ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl )
+ // InternalOXtype.g:4381:2: rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl"
+ // InternalOXtype.g:4387:1: rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl : ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1 ) ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4391:1: ( ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1 ) ) )
+ // InternalOXtype.g:4392:1: ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1 ) )
+ {
+ // InternalOXtype.g:4392:1: ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1 ) )
+ // InternalOXtype.g:4393:2: ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_1_1_1_1());
+ }
+ // InternalOXtype.g:4394:2: ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1 )
+ // InternalOXtype.g:4394:3: rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_1_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0__0"
+ // InternalOXtype.g:4403:1: rule__XAnnotationElementValue__Group_0__0 : rule__XAnnotationElementValue__Group_0__0__Impl rule__XAnnotationElementValue__Group_0__1 ;
+ public final void rule__XAnnotationElementValue__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4407:1: ( rule__XAnnotationElementValue__Group_0__0__Impl rule__XAnnotationElementValue__Group_0__1 )
+ // InternalOXtype.g:4408:2: rule__XAnnotationElementValue__Group_0__0__Impl rule__XAnnotationElementValue__Group_0__1
+ {
+ pushFollow(FOLLOW_17);
+ rule__XAnnotationElementValue__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__Group_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0__0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0__0__Impl"
+ // InternalOXtype.g:4415:1: rule__XAnnotationElementValue__Group_0__0__Impl : ( ( rule__XAnnotationElementValue__Group_0_0__0 ) ) ;
+ public final void rule__XAnnotationElementValue__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4419:1: ( ( ( rule__XAnnotationElementValue__Group_0_0__0 ) ) )
+ // InternalOXtype.g:4420:1: ( ( rule__XAnnotationElementValue__Group_0_0__0 ) )
+ {
+ // InternalOXtype.g:4420:1: ( ( rule__XAnnotationElementValue__Group_0_0__0 ) )
+ // InternalOXtype.g:4421:2: ( rule__XAnnotationElementValue__Group_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0());
+ }
+ // InternalOXtype.g:4422:2: ( rule__XAnnotationElementValue__Group_0_0__0 )
+ // InternalOXtype.g:4422:3: rule__XAnnotationElementValue__Group_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__Group_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0__1"
+ // InternalOXtype.g:4430:1: rule__XAnnotationElementValue__Group_0__1 : rule__XAnnotationElementValue__Group_0__1__Impl rule__XAnnotationElementValue__Group_0__2 ;
+ public final void rule__XAnnotationElementValue__Group_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4434:1: ( rule__XAnnotationElementValue__Group_0__1__Impl rule__XAnnotationElementValue__Group_0__2 )
+ // InternalOXtype.g:4435:2: rule__XAnnotationElementValue__Group_0__1__Impl rule__XAnnotationElementValue__Group_0__2
+ {
+ pushFollow(FOLLOW_17);
+ rule__XAnnotationElementValue__Group_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__Group_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0__1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0__1__Impl"
+ // InternalOXtype.g:4442:1: rule__XAnnotationElementValue__Group_0__1__Impl : ( ( rule__XAnnotationElementValue__Group_0_1__0 )? ) ;
+ public final void rule__XAnnotationElementValue__Group_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4446:1: ( ( ( rule__XAnnotationElementValue__Group_0_1__0 )? ) )
+ // InternalOXtype.g:4447:1: ( ( rule__XAnnotationElementValue__Group_0_1__0 )? )
+ {
+ // InternalOXtype.g:4447:1: ( ( rule__XAnnotationElementValue__Group_0_1__0 )? )
+ // InternalOXtype.g:4448:2: ( rule__XAnnotationElementValue__Group_0_1__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1());
+ }
+ // InternalOXtype.g:4449:2: ( rule__XAnnotationElementValue__Group_0_1__0 )?
+ int alt54=2;
+ int LA54_0 = input.LA(1);
+
+ if ( ((LA54_0>=RULE_ID && LA54_0<=RULE_STRING)||LA54_0==27||(LA54_0>=34 && LA54_0<=35)||LA54_0==40||(LA54_0>=45 && LA54_0<=50)||(LA54_0>=52 && LA54_0<=53)||(LA54_0>=57 && LA54_0<=58)||LA54_0==61||LA54_0==63||LA54_0==65||(LA54_0>=69 && LA54_0<=77)||LA54_0==79||LA54_0==88) ) {
+ alt54=1;
+ }
+ switch (alt54) {
+ case 1 :
+ // InternalOXtype.g:4449:3: rule__XAnnotationElementValue__Group_0_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__Group_0_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0__1__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0__2"
+ // InternalOXtype.g:4457:1: rule__XAnnotationElementValue__Group_0__2 : rule__XAnnotationElementValue__Group_0__2__Impl ;
+ public final void rule__XAnnotationElementValue__Group_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4461:1: ( rule__XAnnotationElementValue__Group_0__2__Impl )
+ // InternalOXtype.g:4462:2: rule__XAnnotationElementValue__Group_0__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__Group_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0__2"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0__2__Impl"
+ // InternalOXtype.g:4468:1: rule__XAnnotationElementValue__Group_0__2__Impl : ( ']' ) ;
+ public final void rule__XAnnotationElementValue__Group_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4472:1: ( ( ']' ) )
+ // InternalOXtype.g:4473:1: ( ']' )
+ {
+ // InternalOXtype.g:4473:1: ( ']' )
+ // InternalOXtype.g:4474:2: ']'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueAccess().getRightSquareBracketKeyword_0_2());
+ }
+ match(input,56,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueAccess().getRightSquareBracketKeyword_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0__2__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0_0__0"
+ // InternalOXtype.g:4484:1: rule__XAnnotationElementValue__Group_0_0__0 : rule__XAnnotationElementValue__Group_0_0__0__Impl ;
+ public final void rule__XAnnotationElementValue__Group_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4488:1: ( rule__XAnnotationElementValue__Group_0_0__0__Impl )
+ // InternalOXtype.g:4489:2: rule__XAnnotationElementValue__Group_0_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__Group_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0_0__0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0_0__0__Impl"
+ // InternalOXtype.g:4495:1: rule__XAnnotationElementValue__Group_0_0__0__Impl : ( ( rule__XAnnotationElementValue__Group_0_0_0__0 ) ) ;
+ public final void rule__XAnnotationElementValue__Group_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4499:1: ( ( ( rule__XAnnotationElementValue__Group_0_0_0__0 ) ) )
+ // InternalOXtype.g:4500:1: ( ( rule__XAnnotationElementValue__Group_0_0_0__0 ) )
+ {
+ // InternalOXtype.g:4500:1: ( ( rule__XAnnotationElementValue__Group_0_0_0__0 ) )
+ // InternalOXtype.g:4501:2: ( rule__XAnnotationElementValue__Group_0_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0_0());
+ }
+ // InternalOXtype.g:4502:2: ( rule__XAnnotationElementValue__Group_0_0_0__0 )
+ // InternalOXtype.g:4502:3: rule__XAnnotationElementValue__Group_0_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__Group_0_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0_0_0__0"
+ // InternalOXtype.g:4511:1: rule__XAnnotationElementValue__Group_0_0_0__0 : rule__XAnnotationElementValue__Group_0_0_0__0__Impl rule__XAnnotationElementValue__Group_0_0_0__1 ;
+ public final void rule__XAnnotationElementValue__Group_0_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4515:1: ( rule__XAnnotationElementValue__Group_0_0_0__0__Impl rule__XAnnotationElementValue__Group_0_0_0__1 )
+ // InternalOXtype.g:4516:2: rule__XAnnotationElementValue__Group_0_0_0__0__Impl rule__XAnnotationElementValue__Group_0_0_0__1
+ {
+ pushFollow(FOLLOW_18);
+ rule__XAnnotationElementValue__Group_0_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__Group_0_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0_0_0__0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0_0_0__0__Impl"
+ // InternalOXtype.g:4523:1: rule__XAnnotationElementValue__Group_0_0_0__0__Impl : ( () ) ;
+ public final void rule__XAnnotationElementValue__Group_0_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4527:1: ( ( () ) )
+ // InternalOXtype.g:4528:1: ( () )
+ {
+ // InternalOXtype.g:4528:1: ( () )
+ // InternalOXtype.g:4529:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueAccess().getXListLiteralAction_0_0_0_0());
+ }
+ // InternalOXtype.g:4530:2: ()
+ // InternalOXtype.g:4530:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueAccess().getXListLiteralAction_0_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0_0_0__1"
+ // InternalOXtype.g:4538:1: rule__XAnnotationElementValue__Group_0_0_0__1 : rule__XAnnotationElementValue__Group_0_0_0__1__Impl rule__XAnnotationElementValue__Group_0_0_0__2 ;
+ public final void rule__XAnnotationElementValue__Group_0_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4542:1: ( rule__XAnnotationElementValue__Group_0_0_0__1__Impl rule__XAnnotationElementValue__Group_0_0_0__2 )
+ // InternalOXtype.g:4543:2: rule__XAnnotationElementValue__Group_0_0_0__1__Impl rule__XAnnotationElementValue__Group_0_0_0__2
+ {
+ pushFollow(FOLLOW_19);
+ rule__XAnnotationElementValue__Group_0_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__Group_0_0_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0_0_0__1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0_0_0__1__Impl"
+ // InternalOXtype.g:4550:1: rule__XAnnotationElementValue__Group_0_0_0__1__Impl : ( '#' ) ;
+ public final void rule__XAnnotationElementValue__Group_0_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4554:1: ( ( '#' ) )
+ // InternalOXtype.g:4555:1: ( '#' )
+ {
+ // InternalOXtype.g:4555:1: ( '#' )
+ // InternalOXtype.g:4556:2: '#'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueAccess().getNumberSignKeyword_0_0_0_1());
+ }
+ match(input,57,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueAccess().getNumberSignKeyword_0_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0_0_0__2"
+ // InternalOXtype.g:4565:1: rule__XAnnotationElementValue__Group_0_0_0__2 : rule__XAnnotationElementValue__Group_0_0_0__2__Impl ;
+ public final void rule__XAnnotationElementValue__Group_0_0_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4569:1: ( rule__XAnnotationElementValue__Group_0_0_0__2__Impl )
+ // InternalOXtype.g:4570:2: rule__XAnnotationElementValue__Group_0_0_0__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__Group_0_0_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0_0_0__2"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0_0_0__2__Impl"
+ // InternalOXtype.g:4576:1: rule__XAnnotationElementValue__Group_0_0_0__2__Impl : ( '[' ) ;
+ public final void rule__XAnnotationElementValue__Group_0_0_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4580:1: ( ( '[' ) )
+ // InternalOXtype.g:4581:1: ( '[' )
+ {
+ // InternalOXtype.g:4581:1: ( '[' )
+ // InternalOXtype.g:4582:2: '['
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueAccess().getLeftSquareBracketKeyword_0_0_0_2());
+ }
+ match(input,58,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueAccess().getLeftSquareBracketKeyword_0_0_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0_0_0__2__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0_1__0"
+ // InternalOXtype.g:4592:1: rule__XAnnotationElementValue__Group_0_1__0 : rule__XAnnotationElementValue__Group_0_1__0__Impl rule__XAnnotationElementValue__Group_0_1__1 ;
+ public final void rule__XAnnotationElementValue__Group_0_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4596:1: ( rule__XAnnotationElementValue__Group_0_1__0__Impl rule__XAnnotationElementValue__Group_0_1__1 )
+ // InternalOXtype.g:4597:2: rule__XAnnotationElementValue__Group_0_1__0__Impl rule__XAnnotationElementValue__Group_0_1__1
+ {
+ pushFollow(FOLLOW_13);
+ rule__XAnnotationElementValue__Group_0_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__Group_0_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0_1__0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0_1__0__Impl"
+ // InternalOXtype.g:4604:1: rule__XAnnotationElementValue__Group_0_1__0__Impl : ( ( rule__XAnnotationElementValue__ElementsAssignment_0_1_0 ) ) ;
+ public final void rule__XAnnotationElementValue__Group_0_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4608:1: ( ( ( rule__XAnnotationElementValue__ElementsAssignment_0_1_0 ) ) )
+ // InternalOXtype.g:4609:1: ( ( rule__XAnnotationElementValue__ElementsAssignment_0_1_0 ) )
+ {
+ // InternalOXtype.g:4609:1: ( ( rule__XAnnotationElementValue__ElementsAssignment_0_1_0 ) )
+ // InternalOXtype.g:4610:2: ( rule__XAnnotationElementValue__ElementsAssignment_0_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_0());
+ }
+ // InternalOXtype.g:4611:2: ( rule__XAnnotationElementValue__ElementsAssignment_0_1_0 )
+ // InternalOXtype.g:4611:3: rule__XAnnotationElementValue__ElementsAssignment_0_1_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__ElementsAssignment_0_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0_1__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0_1__1"
+ // InternalOXtype.g:4619:1: rule__XAnnotationElementValue__Group_0_1__1 : rule__XAnnotationElementValue__Group_0_1__1__Impl ;
+ public final void rule__XAnnotationElementValue__Group_0_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4623:1: ( rule__XAnnotationElementValue__Group_0_1__1__Impl )
+ // InternalOXtype.g:4624:2: rule__XAnnotationElementValue__Group_0_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__Group_0_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0_1__1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0_1__1__Impl"
+ // InternalOXtype.g:4630:1: rule__XAnnotationElementValue__Group_0_1__1__Impl : ( ( rule__XAnnotationElementValue__Group_0_1_1__0 )* ) ;
+ public final void rule__XAnnotationElementValue__Group_0_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4634:1: ( ( ( rule__XAnnotationElementValue__Group_0_1_1__0 )* ) )
+ // InternalOXtype.g:4635:1: ( ( rule__XAnnotationElementValue__Group_0_1_1__0 )* )
+ {
+ // InternalOXtype.g:4635:1: ( ( rule__XAnnotationElementValue__Group_0_1_1__0 )* )
+ // InternalOXtype.g:4636:2: ( rule__XAnnotationElementValue__Group_0_1_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1_1());
+ }
+ // InternalOXtype.g:4637:2: ( rule__XAnnotationElementValue__Group_0_1_1__0 )*
+ loop55:
+ do {
+ int alt55=2;
+ int LA55_0 = input.LA(1);
+
+ if ( (LA55_0==55) ) {
+ alt55=1;
+ }
+
+
+ switch (alt55) {
+ case 1 :
+ // InternalOXtype.g:4637:3: rule__XAnnotationElementValue__Group_0_1_1__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XAnnotationElementValue__Group_0_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop55;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0_1__1__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0_1_1__0"
+ // InternalOXtype.g:4646:1: rule__XAnnotationElementValue__Group_0_1_1__0 : rule__XAnnotationElementValue__Group_0_1_1__0__Impl rule__XAnnotationElementValue__Group_0_1_1__1 ;
+ public final void rule__XAnnotationElementValue__Group_0_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4650:1: ( rule__XAnnotationElementValue__Group_0_1_1__0__Impl rule__XAnnotationElementValue__Group_0_1_1__1 )
+ // InternalOXtype.g:4651:2: rule__XAnnotationElementValue__Group_0_1_1__0__Impl rule__XAnnotationElementValue__Group_0_1_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XAnnotationElementValue__Group_0_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__Group_0_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0_1_1__0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0_1_1__0__Impl"
+ // InternalOXtype.g:4658:1: rule__XAnnotationElementValue__Group_0_1_1__0__Impl : ( ',' ) ;
+ public final void rule__XAnnotationElementValue__Group_0_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4662:1: ( ( ',' ) )
+ // InternalOXtype.g:4663:1: ( ',' )
+ {
+ // InternalOXtype.g:4663:1: ( ',' )
+ // InternalOXtype.g:4664:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueAccess().getCommaKeyword_0_1_1_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueAccess().getCommaKeyword_0_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0_1_1__1"
+ // InternalOXtype.g:4673:1: rule__XAnnotationElementValue__Group_0_1_1__1 : rule__XAnnotationElementValue__Group_0_1_1__1__Impl ;
+ public final void rule__XAnnotationElementValue__Group_0_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4677:1: ( rule__XAnnotationElementValue__Group_0_1_1__1__Impl )
+ // InternalOXtype.g:4678:2: rule__XAnnotationElementValue__Group_0_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__Group_0_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0_1_1__1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__Group_0_1_1__1__Impl"
+ // InternalOXtype.g:4684:1: rule__XAnnotationElementValue__Group_0_1_1__1__Impl : ( ( rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1 ) ) ;
+ public final void rule__XAnnotationElementValue__Group_0_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4688:1: ( ( ( rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1 ) ) )
+ // InternalOXtype.g:4689:1: ( ( rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1 ) )
+ {
+ // InternalOXtype.g:4689:1: ( ( rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1 ) )
+ // InternalOXtype.g:4690:2: ( rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_1_1());
+ }
+ // InternalOXtype.g:4691:2: ( rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1 )
+ // InternalOXtype.g:4691:3: rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__Group_0_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__XAssignment__Group_0__0"
+ // InternalOXtype.g:4700:1: rule__XAssignment__Group_0__0 : rule__XAssignment__Group_0__0__Impl rule__XAssignment__Group_0__1 ;
+ public final void rule__XAssignment__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4704:1: ( rule__XAssignment__Group_0__0__Impl rule__XAssignment__Group_0__1 )
+ // InternalOXtype.g:4705:2: rule__XAssignment__Group_0__0__Impl rule__XAssignment__Group_0__1
+ {
+ pushFollow(FOLLOW_20);
+ rule__XAssignment__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Group_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_0__0"
+
+
+ // $ANTLR start "rule__XAssignment__Group_0__0__Impl"
+ // InternalOXtype.g:4712:1: rule__XAssignment__Group_0__0__Impl : ( () ) ;
+ public final void rule__XAssignment__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4716:1: ( ( () ) )
+ // InternalOXtype.g:4717:1: ( () )
+ {
+ // InternalOXtype.g:4717:1: ( () )
+ // InternalOXtype.g:4718:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0());
+ }
+ // InternalOXtype.g:4719:2: ()
+ // InternalOXtype.g:4719:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__XAssignment__Group_0__1"
+ // InternalOXtype.g:4727:1: rule__XAssignment__Group_0__1 : rule__XAssignment__Group_0__1__Impl rule__XAssignment__Group_0__2 ;
+ public final void rule__XAssignment__Group_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4731:1: ( rule__XAssignment__Group_0__1__Impl rule__XAssignment__Group_0__2 )
+ // InternalOXtype.g:4732:2: rule__XAssignment__Group_0__1__Impl rule__XAssignment__Group_0__2
+ {
+ pushFollow(FOLLOW_16);
+ rule__XAssignment__Group_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Group_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_0__1"
+
+
+ // $ANTLR start "rule__XAssignment__Group_0__1__Impl"
+ // InternalOXtype.g:4739:1: rule__XAssignment__Group_0__1__Impl : ( ( rule__XAssignment__FeatureAssignment_0_1 ) ) ;
+ public final void rule__XAssignment__Group_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4743:1: ( ( ( rule__XAssignment__FeatureAssignment_0_1 ) ) )
+ // InternalOXtype.g:4744:1: ( ( rule__XAssignment__FeatureAssignment_0_1 ) )
+ {
+ // InternalOXtype.g:4744:1: ( ( rule__XAssignment__FeatureAssignment_0_1 ) )
+ // InternalOXtype.g:4745:2: ( rule__XAssignment__FeatureAssignment_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1());
+ }
+ // InternalOXtype.g:4746:2: ( rule__XAssignment__FeatureAssignment_0_1 )
+ // InternalOXtype.g:4746:3: rule__XAssignment__FeatureAssignment_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__FeatureAssignment_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_0__1__Impl"
+
+
+ // $ANTLR start "rule__XAssignment__Group_0__2"
+ // InternalOXtype.g:4754:1: rule__XAssignment__Group_0__2 : rule__XAssignment__Group_0__2__Impl rule__XAssignment__Group_0__3 ;
+ public final void rule__XAssignment__Group_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4758:1: ( rule__XAssignment__Group_0__2__Impl rule__XAssignment__Group_0__3 )
+ // InternalOXtype.g:4759:2: rule__XAssignment__Group_0__2__Impl rule__XAssignment__Group_0__3
+ {
+ pushFollow(FOLLOW_15);
+ rule__XAssignment__Group_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Group_0__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_0__2"
+
+
+ // $ANTLR start "rule__XAssignment__Group_0__2__Impl"
+ // InternalOXtype.g:4766:1: rule__XAssignment__Group_0__2__Impl : ( ruleOpSingleAssign ) ;
+ public final void rule__XAssignment__Group_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4770:1: ( ( ruleOpSingleAssign ) )
+ // InternalOXtype.g:4771:1: ( ruleOpSingleAssign )
+ {
+ // InternalOXtype.g:4771:1: ( ruleOpSingleAssign )
+ // InternalOXtype.g:4772:2: ruleOpSingleAssign
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2());
+ }
+ pushFollow(FOLLOW_2);
+ ruleOpSingleAssign();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_0__2__Impl"
+
+
+ // $ANTLR start "rule__XAssignment__Group_0__3"
+ // InternalOXtype.g:4781:1: rule__XAssignment__Group_0__3 : rule__XAssignment__Group_0__3__Impl ;
+ public final void rule__XAssignment__Group_0__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4785:1: ( rule__XAssignment__Group_0__3__Impl )
+ // InternalOXtype.g:4786:2: rule__XAssignment__Group_0__3__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Group_0__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_0__3"
+
+
+ // $ANTLR start "rule__XAssignment__Group_0__3__Impl"
+ // InternalOXtype.g:4792:1: rule__XAssignment__Group_0__3__Impl : ( ( rule__XAssignment__ValueAssignment_0_3 ) ) ;
+ public final void rule__XAssignment__Group_0__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4796:1: ( ( ( rule__XAssignment__ValueAssignment_0_3 ) ) )
+ // InternalOXtype.g:4797:1: ( ( rule__XAssignment__ValueAssignment_0_3 ) )
+ {
+ // InternalOXtype.g:4797:1: ( ( rule__XAssignment__ValueAssignment_0_3 ) )
+ // InternalOXtype.g:4798:2: ( rule__XAssignment__ValueAssignment_0_3 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3());
+ }
+ // InternalOXtype.g:4799:2: ( rule__XAssignment__ValueAssignment_0_3 )
+ // InternalOXtype.g:4799:3: rule__XAssignment__ValueAssignment_0_3
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__ValueAssignment_0_3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_0__3__Impl"
+
+
+ // $ANTLR start "rule__XAssignment__Group_1__0"
+ // InternalOXtype.g:4808:1: rule__XAssignment__Group_1__0 : rule__XAssignment__Group_1__0__Impl rule__XAssignment__Group_1__1 ;
+ public final void rule__XAssignment__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4812:1: ( rule__XAssignment__Group_1__0__Impl rule__XAssignment__Group_1__1 )
+ // InternalOXtype.g:4813:2: rule__XAssignment__Group_1__0__Impl rule__XAssignment__Group_1__1
+ {
+ pushFollow(FOLLOW_21);
+ rule__XAssignment__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_1__0"
+
+
+ // $ANTLR start "rule__XAssignment__Group_1__0__Impl"
+ // InternalOXtype.g:4820:1: rule__XAssignment__Group_1__0__Impl : ( ruleXOrExpression ) ;
+ public final void rule__XAssignment__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4824:1: ( ( ruleXOrExpression ) )
+ // InternalOXtype.g:4825:1: ( ruleXOrExpression )
+ {
+ // InternalOXtype.g:4825:1: ( ruleXOrExpression )
+ // InternalOXtype.g:4826:2: ruleXOrExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXOrExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__XAssignment__Group_1__1"
+ // InternalOXtype.g:4835:1: rule__XAssignment__Group_1__1 : rule__XAssignment__Group_1__1__Impl ;
+ public final void rule__XAssignment__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4839:1: ( rule__XAssignment__Group_1__1__Impl )
+ // InternalOXtype.g:4840:2: rule__XAssignment__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_1__1"
+
+
+ // $ANTLR start "rule__XAssignment__Group_1__1__Impl"
+ // InternalOXtype.g:4846:1: rule__XAssignment__Group_1__1__Impl : ( ( rule__XAssignment__Group_1_1__0 )? ) ;
+ public final void rule__XAssignment__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4850:1: ( ( ( rule__XAssignment__Group_1_1__0 )? ) )
+ // InternalOXtype.g:4851:1: ( ( rule__XAssignment__Group_1_1__0 )? )
+ {
+ // InternalOXtype.g:4851:1: ( ( rule__XAssignment__Group_1_1__0 )? )
+ // InternalOXtype.g:4852:2: ( rule__XAssignment__Group_1_1__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getGroup_1_1());
+ }
+ // InternalOXtype.g:4853:2: ( rule__XAssignment__Group_1_1__0 )?
+ int alt56=2;
+ alt56 = dfa56.predict(input);
+ switch (alt56) {
+ case 1 :
+ // InternalOXtype.g:4853:3: rule__XAssignment__Group_1_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Group_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getGroup_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__XAssignment__Group_1_1__0"
+ // InternalOXtype.g:4862:1: rule__XAssignment__Group_1_1__0 : rule__XAssignment__Group_1_1__0__Impl rule__XAssignment__Group_1_1__1 ;
+ public final void rule__XAssignment__Group_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4866:1: ( rule__XAssignment__Group_1_1__0__Impl rule__XAssignment__Group_1_1__1 )
+ // InternalOXtype.g:4867:2: rule__XAssignment__Group_1_1__0__Impl rule__XAssignment__Group_1_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XAssignment__Group_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Group_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_1_1__0"
+
+
+ // $ANTLR start "rule__XAssignment__Group_1_1__0__Impl"
+ // InternalOXtype.g:4874:1: rule__XAssignment__Group_1_1__0__Impl : ( ( rule__XAssignment__Group_1_1_0__0 ) ) ;
+ public final void rule__XAssignment__Group_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4878:1: ( ( ( rule__XAssignment__Group_1_1_0__0 ) ) )
+ // InternalOXtype.g:4879:1: ( ( rule__XAssignment__Group_1_1_0__0 ) )
+ {
+ // InternalOXtype.g:4879:1: ( ( rule__XAssignment__Group_1_1_0__0 ) )
+ // InternalOXtype.g:4880:2: ( rule__XAssignment__Group_1_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0());
+ }
+ // InternalOXtype.g:4881:2: ( rule__XAssignment__Group_1_1_0__0 )
+ // InternalOXtype.g:4881:3: rule__XAssignment__Group_1_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Group_1_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__XAssignment__Group_1_1__1"
+ // InternalOXtype.g:4889:1: rule__XAssignment__Group_1_1__1 : rule__XAssignment__Group_1_1__1__Impl ;
+ public final void rule__XAssignment__Group_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4893:1: ( rule__XAssignment__Group_1_1__1__Impl )
+ // InternalOXtype.g:4894:2: rule__XAssignment__Group_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Group_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_1_1__1"
+
+
+ // $ANTLR start "rule__XAssignment__Group_1_1__1__Impl"
+ // InternalOXtype.g:4900:1: rule__XAssignment__Group_1_1__1__Impl : ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) ) ;
+ public final void rule__XAssignment__Group_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4904:1: ( ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) ) )
+ // InternalOXtype.g:4905:1: ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) )
+ {
+ // InternalOXtype.g:4905:1: ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) )
+ // InternalOXtype.g:4906:2: ( rule__XAssignment__RightOperandAssignment_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1());
+ }
+ // InternalOXtype.g:4907:2: ( rule__XAssignment__RightOperandAssignment_1_1_1 )
+ // InternalOXtype.g:4907:3: rule__XAssignment__RightOperandAssignment_1_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__RightOperandAssignment_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__XAssignment__Group_1_1_0__0"
+ // InternalOXtype.g:4916:1: rule__XAssignment__Group_1_1_0__0 : rule__XAssignment__Group_1_1_0__0__Impl ;
+ public final void rule__XAssignment__Group_1_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4920:1: ( rule__XAssignment__Group_1_1_0__0__Impl )
+ // InternalOXtype.g:4921:2: rule__XAssignment__Group_1_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Group_1_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_1_1_0__0"
+
+
+ // $ANTLR start "rule__XAssignment__Group_1_1_0__0__Impl"
+ // InternalOXtype.g:4927:1: rule__XAssignment__Group_1_1_0__0__Impl : ( ( rule__XAssignment__Group_1_1_0_0__0 ) ) ;
+ public final void rule__XAssignment__Group_1_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4931:1: ( ( ( rule__XAssignment__Group_1_1_0_0__0 ) ) )
+ // InternalOXtype.g:4932:1: ( ( rule__XAssignment__Group_1_1_0_0__0 ) )
+ {
+ // InternalOXtype.g:4932:1: ( ( rule__XAssignment__Group_1_1_0_0__0 ) )
+ // InternalOXtype.g:4933:2: ( rule__XAssignment__Group_1_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0());
+ }
+ // InternalOXtype.g:4934:2: ( rule__XAssignment__Group_1_1_0_0__0 )
+ // InternalOXtype.g:4934:3: rule__XAssignment__Group_1_1_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Group_1_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_1_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__XAssignment__Group_1_1_0_0__0"
+ // InternalOXtype.g:4943:1: rule__XAssignment__Group_1_1_0_0__0 : rule__XAssignment__Group_1_1_0_0__0__Impl rule__XAssignment__Group_1_1_0_0__1 ;
+ public final void rule__XAssignment__Group_1_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4947:1: ( rule__XAssignment__Group_1_1_0_0__0__Impl rule__XAssignment__Group_1_1_0_0__1 )
+ // InternalOXtype.g:4948:2: rule__XAssignment__Group_1_1_0_0__0__Impl rule__XAssignment__Group_1_1_0_0__1
+ {
+ pushFollow(FOLLOW_21);
+ rule__XAssignment__Group_1_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Group_1_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_1_1_0_0__0"
+
+
+ // $ANTLR start "rule__XAssignment__Group_1_1_0_0__0__Impl"
+ // InternalOXtype.g:4955:1: rule__XAssignment__Group_1_1_0_0__0__Impl : ( () ) ;
+ public final void rule__XAssignment__Group_1_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4959:1: ( ( () ) )
+ // InternalOXtype.g:4960:1: ( () )
+ {
+ // InternalOXtype.g:4960:1: ( () )
+ // InternalOXtype.g:4961:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0());
+ }
+ // InternalOXtype.g:4962:2: ()
+ // InternalOXtype.g:4962:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_1_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XAssignment__Group_1_1_0_0__1"
+ // InternalOXtype.g:4970:1: rule__XAssignment__Group_1_1_0_0__1 : rule__XAssignment__Group_1_1_0_0__1__Impl ;
+ public final void rule__XAssignment__Group_1_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4974:1: ( rule__XAssignment__Group_1_1_0_0__1__Impl )
+ // InternalOXtype.g:4975:2: rule__XAssignment__Group_1_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Group_1_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_1_1_0_0__1"
+
+
+ // $ANTLR start "rule__XAssignment__Group_1_1_0_0__1__Impl"
+ // InternalOXtype.g:4981:1: rule__XAssignment__Group_1_1_0_0__1__Impl : ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) ) ;
+ public final void rule__XAssignment__Group_1_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:4985:1: ( ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) ) )
+ // InternalOXtype.g:4986:1: ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) )
+ {
+ // InternalOXtype.g:4986:1: ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) )
+ // InternalOXtype.g:4987:2: ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1());
+ }
+ // InternalOXtype.g:4988:2: ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 )
+ // InternalOXtype.g:4988:3: rule__XAssignment__FeatureAssignment_1_1_0_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__FeatureAssignment_1_1_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__Group_1_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__OpMultiAssign__Group_5__0"
+ // InternalOXtype.g:4997:1: rule__OpMultiAssign__Group_5__0 : rule__OpMultiAssign__Group_5__0__Impl rule__OpMultiAssign__Group_5__1 ;
+ public final void rule__OpMultiAssign__Group_5__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5001:1: ( rule__OpMultiAssign__Group_5__0__Impl rule__OpMultiAssign__Group_5__1 )
+ // InternalOXtype.g:5002:2: rule__OpMultiAssign__Group_5__0__Impl rule__OpMultiAssign__Group_5__1
+ {
+ pushFollow(FOLLOW_22);
+ rule__OpMultiAssign__Group_5__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__OpMultiAssign__Group_5__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpMultiAssign__Group_5__0"
+
+
+ // $ANTLR start "rule__OpMultiAssign__Group_5__0__Impl"
+ // InternalOXtype.g:5009:1: rule__OpMultiAssign__Group_5__0__Impl : ( '<' ) ;
+ public final void rule__OpMultiAssign__Group_5__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5013:1: ( ( '<' ) )
+ // InternalOXtype.g:5014:1: ( '<' )
+ {
+ // InternalOXtype.g:5014:1: ( '<' )
+ // InternalOXtype.g:5015:2: '<'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0());
+ }
+ match(input,27,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpMultiAssign__Group_5__0__Impl"
+
+
+ // $ANTLR start "rule__OpMultiAssign__Group_5__1"
+ // InternalOXtype.g:5024:1: rule__OpMultiAssign__Group_5__1 : rule__OpMultiAssign__Group_5__1__Impl rule__OpMultiAssign__Group_5__2 ;
+ public final void rule__OpMultiAssign__Group_5__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5028:1: ( rule__OpMultiAssign__Group_5__1__Impl rule__OpMultiAssign__Group_5__2 )
+ // InternalOXtype.g:5029:2: rule__OpMultiAssign__Group_5__1__Impl rule__OpMultiAssign__Group_5__2
+ {
+ pushFollow(FOLLOW_16);
+ rule__OpMultiAssign__Group_5__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__OpMultiAssign__Group_5__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpMultiAssign__Group_5__1"
+
+
+ // $ANTLR start "rule__OpMultiAssign__Group_5__1__Impl"
+ // InternalOXtype.g:5036:1: rule__OpMultiAssign__Group_5__1__Impl : ( '<' ) ;
+ public final void rule__OpMultiAssign__Group_5__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5040:1: ( ( '<' ) )
+ // InternalOXtype.g:5041:1: ( '<' )
+ {
+ // InternalOXtype.g:5041:1: ( '<' )
+ // InternalOXtype.g:5042:2: '<'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1());
+ }
+ match(input,27,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpMultiAssign__Group_5__1__Impl"
+
+
+ // $ANTLR start "rule__OpMultiAssign__Group_5__2"
+ // InternalOXtype.g:5051:1: rule__OpMultiAssign__Group_5__2 : rule__OpMultiAssign__Group_5__2__Impl ;
+ public final void rule__OpMultiAssign__Group_5__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5055:1: ( rule__OpMultiAssign__Group_5__2__Impl )
+ // InternalOXtype.g:5056:2: rule__OpMultiAssign__Group_5__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpMultiAssign__Group_5__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpMultiAssign__Group_5__2"
+
+
+ // $ANTLR start "rule__OpMultiAssign__Group_5__2__Impl"
+ // InternalOXtype.g:5062:1: rule__OpMultiAssign__Group_5__2__Impl : ( '=' ) ;
+ public final void rule__OpMultiAssign__Group_5__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5066:1: ( ( '=' ) )
+ // InternalOXtype.g:5067:1: ( '=' )
+ {
+ // InternalOXtype.g:5067:1: ( '=' )
+ // InternalOXtype.g:5068:2: '='
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2());
+ }
+ match(input,13,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpMultiAssign__Group_5__2__Impl"
+
+
+ // $ANTLR start "rule__OpMultiAssign__Group_6__0"
+ // InternalOXtype.g:5078:1: rule__OpMultiAssign__Group_6__0 : rule__OpMultiAssign__Group_6__0__Impl rule__OpMultiAssign__Group_6__1 ;
+ public final void rule__OpMultiAssign__Group_6__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5082:1: ( rule__OpMultiAssign__Group_6__0__Impl rule__OpMultiAssign__Group_6__1 )
+ // InternalOXtype.g:5083:2: rule__OpMultiAssign__Group_6__0__Impl rule__OpMultiAssign__Group_6__1
+ {
+ pushFollow(FOLLOW_23);
+ rule__OpMultiAssign__Group_6__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__OpMultiAssign__Group_6__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpMultiAssign__Group_6__0"
+
+
+ // $ANTLR start "rule__OpMultiAssign__Group_6__0__Impl"
+ // InternalOXtype.g:5090:1: rule__OpMultiAssign__Group_6__0__Impl : ( '>' ) ;
+ public final void rule__OpMultiAssign__Group_6__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5094:1: ( ( '>' ) )
+ // InternalOXtype.g:5095:1: ( '>' )
+ {
+ // InternalOXtype.g:5095:1: ( '>' )
+ // InternalOXtype.g:5096:2: '>'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0());
+ }
+ match(input,26,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpMultiAssign__Group_6__0__Impl"
+
+
+ // $ANTLR start "rule__OpMultiAssign__Group_6__1"
+ // InternalOXtype.g:5105:1: rule__OpMultiAssign__Group_6__1 : rule__OpMultiAssign__Group_6__1__Impl rule__OpMultiAssign__Group_6__2 ;
+ public final void rule__OpMultiAssign__Group_6__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5109:1: ( rule__OpMultiAssign__Group_6__1__Impl rule__OpMultiAssign__Group_6__2 )
+ // InternalOXtype.g:5110:2: rule__OpMultiAssign__Group_6__1__Impl rule__OpMultiAssign__Group_6__2
+ {
+ pushFollow(FOLLOW_23);
+ rule__OpMultiAssign__Group_6__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__OpMultiAssign__Group_6__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpMultiAssign__Group_6__1"
+
+
+ // $ANTLR start "rule__OpMultiAssign__Group_6__1__Impl"
+ // InternalOXtype.g:5117:1: rule__OpMultiAssign__Group_6__1__Impl : ( ( '>' )? ) ;
+ public final void rule__OpMultiAssign__Group_6__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5121:1: ( ( ( '>' )? ) )
+ // InternalOXtype.g:5122:1: ( ( '>' )? )
+ {
+ // InternalOXtype.g:5122:1: ( ( '>' )? )
+ // InternalOXtype.g:5123:2: ( '>' )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1());
+ }
+ // InternalOXtype.g:5124:2: ( '>' )?
+ int alt57=2;
+ int LA57_0 = input.LA(1);
+
+ if ( (LA57_0==26) ) {
+ alt57=1;
+ }
+ switch (alt57) {
+ case 1 :
+ // InternalOXtype.g:5124:3: '>'
+ {
+ match(input,26,FOLLOW_2); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpMultiAssign__Group_6__1__Impl"
+
+
+ // $ANTLR start "rule__OpMultiAssign__Group_6__2"
+ // InternalOXtype.g:5132:1: rule__OpMultiAssign__Group_6__2 : rule__OpMultiAssign__Group_6__2__Impl ;
+ public final void rule__OpMultiAssign__Group_6__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5136:1: ( rule__OpMultiAssign__Group_6__2__Impl )
+ // InternalOXtype.g:5137:2: rule__OpMultiAssign__Group_6__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpMultiAssign__Group_6__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpMultiAssign__Group_6__2"
+
+
+ // $ANTLR start "rule__OpMultiAssign__Group_6__2__Impl"
+ // InternalOXtype.g:5143:1: rule__OpMultiAssign__Group_6__2__Impl : ( '>=' ) ;
+ public final void rule__OpMultiAssign__Group_6__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5147:1: ( ( '>=' ) )
+ // InternalOXtype.g:5148:1: ( '>=' )
+ {
+ // InternalOXtype.g:5148:1: ( '>=' )
+ // InternalOXtype.g:5149:2: '>='
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2());
+ }
+ match(input,25,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpMultiAssign__Group_6__2__Impl"
+
+
+ // $ANTLR start "rule__XOrExpression__Group__0"
+ // InternalOXtype.g:5159:1: rule__XOrExpression__Group__0 : rule__XOrExpression__Group__0__Impl rule__XOrExpression__Group__1 ;
+ public final void rule__XOrExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5163:1: ( rule__XOrExpression__Group__0__Impl rule__XOrExpression__Group__1 )
+ // InternalOXtype.g:5164:2: rule__XOrExpression__Group__0__Impl rule__XOrExpression__Group__1
+ {
+ pushFollow(FOLLOW_24);
+ rule__XOrExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XOrExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOrExpression__Group__0"
+
+
+ // $ANTLR start "rule__XOrExpression__Group__0__Impl"
+ // InternalOXtype.g:5171:1: rule__XOrExpression__Group__0__Impl : ( ruleXAndExpression ) ;
+ public final void rule__XOrExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5175:1: ( ( ruleXAndExpression ) )
+ // InternalOXtype.g:5176:1: ( ruleXAndExpression )
+ {
+ // InternalOXtype.g:5176:1: ( ruleXAndExpression )
+ // InternalOXtype.g:5177:2: ruleXAndExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAndExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOrExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XOrExpression__Group__1"
+ // InternalOXtype.g:5186:1: rule__XOrExpression__Group__1 : rule__XOrExpression__Group__1__Impl ;
+ public final void rule__XOrExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5190:1: ( rule__XOrExpression__Group__1__Impl )
+ // InternalOXtype.g:5191:2: rule__XOrExpression__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOrExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOrExpression__Group__1"
+
+
+ // $ANTLR start "rule__XOrExpression__Group__1__Impl"
+ // InternalOXtype.g:5197:1: rule__XOrExpression__Group__1__Impl : ( ( rule__XOrExpression__Group_1__0 )* ) ;
+ public final void rule__XOrExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5201:1: ( ( ( rule__XOrExpression__Group_1__0 )* ) )
+ // InternalOXtype.g:5202:1: ( ( rule__XOrExpression__Group_1__0 )* )
+ {
+ // InternalOXtype.g:5202:1: ( ( rule__XOrExpression__Group_1__0 )* )
+ // InternalOXtype.g:5203:2: ( rule__XOrExpression__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOrExpressionAccess().getGroup_1());
+ }
+ // InternalOXtype.g:5204:2: ( rule__XOrExpression__Group_1__0 )*
+ loop58:
+ do {
+ int alt58=2;
+ int LA58_0 = input.LA(1);
+
+ if ( (LA58_0==14) ) {
+ int LA58_2 = input.LA(2);
+
+ if ( (synpred102_InternalOXtype()) ) {
+ alt58=1;
+ }
+
+
+ }
+
+
+ switch (alt58) {
+ case 1 :
+ // InternalOXtype.g:5204:3: rule__XOrExpression__Group_1__0
+ {
+ pushFollow(FOLLOW_25);
+ rule__XOrExpression__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop58;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOrExpressionAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOrExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XOrExpression__Group_1__0"
+ // InternalOXtype.g:5213:1: rule__XOrExpression__Group_1__0 : rule__XOrExpression__Group_1__0__Impl rule__XOrExpression__Group_1__1 ;
+ public final void rule__XOrExpression__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5217:1: ( rule__XOrExpression__Group_1__0__Impl rule__XOrExpression__Group_1__1 )
+ // InternalOXtype.g:5218:2: rule__XOrExpression__Group_1__0__Impl rule__XOrExpression__Group_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XOrExpression__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XOrExpression__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOrExpression__Group_1__0"
+
+
+ // $ANTLR start "rule__XOrExpression__Group_1__0__Impl"
+ // InternalOXtype.g:5225:1: rule__XOrExpression__Group_1__0__Impl : ( ( rule__XOrExpression__Group_1_0__0 ) ) ;
+ public final void rule__XOrExpression__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5229:1: ( ( ( rule__XOrExpression__Group_1_0__0 ) ) )
+ // InternalOXtype.g:5230:1: ( ( rule__XOrExpression__Group_1_0__0 ) )
+ {
+ // InternalOXtype.g:5230:1: ( ( rule__XOrExpression__Group_1_0__0 ) )
+ // InternalOXtype.g:5231:2: ( rule__XOrExpression__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOrExpressionAccess().getGroup_1_0());
+ }
+ // InternalOXtype.g:5232:2: ( rule__XOrExpression__Group_1_0__0 )
+ // InternalOXtype.g:5232:3: rule__XOrExpression__Group_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOrExpression__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOrExpressionAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOrExpression__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__XOrExpression__Group_1__1"
+ // InternalOXtype.g:5240:1: rule__XOrExpression__Group_1__1 : rule__XOrExpression__Group_1__1__Impl ;
+ public final void rule__XOrExpression__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5244:1: ( rule__XOrExpression__Group_1__1__Impl )
+ // InternalOXtype.g:5245:2: rule__XOrExpression__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOrExpression__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOrExpression__Group_1__1"
+
+
+ // $ANTLR start "rule__XOrExpression__Group_1__1__Impl"
+ // InternalOXtype.g:5251:1: rule__XOrExpression__Group_1__1__Impl : ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) ) ;
+ public final void rule__XOrExpression__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5255:1: ( ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) ) )
+ // InternalOXtype.g:5256:1: ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) )
+ {
+ // InternalOXtype.g:5256:1: ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) )
+ // InternalOXtype.g:5257:2: ( rule__XOrExpression__RightOperandAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1());
+ }
+ // InternalOXtype.g:5258:2: ( rule__XOrExpression__RightOperandAssignment_1_1 )
+ // InternalOXtype.g:5258:3: rule__XOrExpression__RightOperandAssignment_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOrExpression__RightOperandAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOrExpression__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__XOrExpression__Group_1_0__0"
+ // InternalOXtype.g:5267:1: rule__XOrExpression__Group_1_0__0 : rule__XOrExpression__Group_1_0__0__Impl ;
+ public final void rule__XOrExpression__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5271:1: ( rule__XOrExpression__Group_1_0__0__Impl )
+ // InternalOXtype.g:5272:2: rule__XOrExpression__Group_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOrExpression__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOrExpression__Group_1_0__0"
+
+
+ // $ANTLR start "rule__XOrExpression__Group_1_0__0__Impl"
+ // InternalOXtype.g:5278:1: rule__XOrExpression__Group_1_0__0__Impl : ( ( rule__XOrExpression__Group_1_0_0__0 ) ) ;
+ public final void rule__XOrExpression__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5282:1: ( ( ( rule__XOrExpression__Group_1_0_0__0 ) ) )
+ // InternalOXtype.g:5283:1: ( ( rule__XOrExpression__Group_1_0_0__0 ) )
+ {
+ // InternalOXtype.g:5283:1: ( ( rule__XOrExpression__Group_1_0_0__0 ) )
+ // InternalOXtype.g:5284:2: ( rule__XOrExpression__Group_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0());
+ }
+ // InternalOXtype.g:5285:2: ( rule__XOrExpression__Group_1_0_0__0 )
+ // InternalOXtype.g:5285:3: rule__XOrExpression__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOrExpression__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOrExpression__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__XOrExpression__Group_1_0_0__0"
+ // InternalOXtype.g:5294:1: rule__XOrExpression__Group_1_0_0__0 : rule__XOrExpression__Group_1_0_0__0__Impl rule__XOrExpression__Group_1_0_0__1 ;
+ public final void rule__XOrExpression__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5298:1: ( rule__XOrExpression__Group_1_0_0__0__Impl rule__XOrExpression__Group_1_0_0__1 )
+ // InternalOXtype.g:5299:2: rule__XOrExpression__Group_1_0_0__0__Impl rule__XOrExpression__Group_1_0_0__1
+ {
+ pushFollow(FOLLOW_24);
+ rule__XOrExpression__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XOrExpression__Group_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOrExpression__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__XOrExpression__Group_1_0_0__0__Impl"
+ // InternalOXtype.g:5306:1: rule__XOrExpression__Group_1_0_0__0__Impl : ( () ) ;
+ public final void rule__XOrExpression__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5310:1: ( ( () ) )
+ // InternalOXtype.g:5311:1: ( () )
+ {
+ // InternalOXtype.g:5311:1: ( () )
+ // InternalOXtype.g:5312:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0());
+ }
+ // InternalOXtype.g:5313:2: ()
+ // InternalOXtype.g:5313:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOrExpression__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XOrExpression__Group_1_0_0__1"
+ // InternalOXtype.g:5321:1: rule__XOrExpression__Group_1_0_0__1 : rule__XOrExpression__Group_1_0_0__1__Impl ;
+ public final void rule__XOrExpression__Group_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5325:1: ( rule__XOrExpression__Group_1_0_0__1__Impl )
+ // InternalOXtype.g:5326:2: rule__XOrExpression__Group_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOrExpression__Group_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOrExpression__Group_1_0_0__1"
+
+
+ // $ANTLR start "rule__XOrExpression__Group_1_0_0__1__Impl"
+ // InternalOXtype.g:5332:1: rule__XOrExpression__Group_1_0_0__1__Impl : ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) ) ;
+ public final void rule__XOrExpression__Group_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5336:1: ( ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) ) )
+ // InternalOXtype.g:5337:1: ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) )
+ {
+ // InternalOXtype.g:5337:1: ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) )
+ // InternalOXtype.g:5338:2: ( rule__XOrExpression__FeatureAssignment_1_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1());
+ }
+ // InternalOXtype.g:5339:2: ( rule__XOrExpression__FeatureAssignment_1_0_0_1 )
+ // InternalOXtype.g:5339:3: rule__XOrExpression__FeatureAssignment_1_0_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOrExpression__FeatureAssignment_1_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOrExpression__Group_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XAndExpression__Group__0"
+ // InternalOXtype.g:5348:1: rule__XAndExpression__Group__0 : rule__XAndExpression__Group__0__Impl rule__XAndExpression__Group__1 ;
+ public final void rule__XAndExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5352:1: ( rule__XAndExpression__Group__0__Impl rule__XAndExpression__Group__1 )
+ // InternalOXtype.g:5353:2: rule__XAndExpression__Group__0__Impl rule__XAndExpression__Group__1
+ {
+ pushFollow(FOLLOW_26);
+ rule__XAndExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAndExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAndExpression__Group__0"
+
+
+ // $ANTLR start "rule__XAndExpression__Group__0__Impl"
+ // InternalOXtype.g:5360:1: rule__XAndExpression__Group__0__Impl : ( ruleXEqualityExpression ) ;
+ public final void rule__XAndExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5364:1: ( ( ruleXEqualityExpression ) )
+ // InternalOXtype.g:5365:1: ( ruleXEqualityExpression )
+ {
+ // InternalOXtype.g:5365:1: ( ruleXEqualityExpression )
+ // InternalOXtype.g:5366:2: ruleXEqualityExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXEqualityExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAndExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XAndExpression__Group__1"
+ // InternalOXtype.g:5375:1: rule__XAndExpression__Group__1 : rule__XAndExpression__Group__1__Impl ;
+ public final void rule__XAndExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5379:1: ( rule__XAndExpression__Group__1__Impl )
+ // InternalOXtype.g:5380:2: rule__XAndExpression__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAndExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAndExpression__Group__1"
+
+
+ // $ANTLR start "rule__XAndExpression__Group__1__Impl"
+ // InternalOXtype.g:5386:1: rule__XAndExpression__Group__1__Impl : ( ( rule__XAndExpression__Group_1__0 )* ) ;
+ public final void rule__XAndExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5390:1: ( ( ( rule__XAndExpression__Group_1__0 )* ) )
+ // InternalOXtype.g:5391:1: ( ( rule__XAndExpression__Group_1__0 )* )
+ {
+ // InternalOXtype.g:5391:1: ( ( rule__XAndExpression__Group_1__0 )* )
+ // InternalOXtype.g:5392:2: ( rule__XAndExpression__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAndExpressionAccess().getGroup_1());
+ }
+ // InternalOXtype.g:5393:2: ( rule__XAndExpression__Group_1__0 )*
+ loop59:
+ do {
+ int alt59=2;
+ int LA59_0 = input.LA(1);
+
+ if ( (LA59_0==15) ) {
+ int LA59_2 = input.LA(2);
+
+ if ( (synpred103_InternalOXtype()) ) {
+ alt59=1;
+ }
+
+
+ }
+
+
+ switch (alt59) {
+ case 1 :
+ // InternalOXtype.g:5393:3: rule__XAndExpression__Group_1__0
+ {
+ pushFollow(FOLLOW_27);
+ rule__XAndExpression__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop59;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAndExpressionAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAndExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XAndExpression__Group_1__0"
+ // InternalOXtype.g:5402:1: rule__XAndExpression__Group_1__0 : rule__XAndExpression__Group_1__0__Impl rule__XAndExpression__Group_1__1 ;
+ public final void rule__XAndExpression__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5406:1: ( rule__XAndExpression__Group_1__0__Impl rule__XAndExpression__Group_1__1 )
+ // InternalOXtype.g:5407:2: rule__XAndExpression__Group_1__0__Impl rule__XAndExpression__Group_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XAndExpression__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAndExpression__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAndExpression__Group_1__0"
+
+
+ // $ANTLR start "rule__XAndExpression__Group_1__0__Impl"
+ // InternalOXtype.g:5414:1: rule__XAndExpression__Group_1__0__Impl : ( ( rule__XAndExpression__Group_1_0__0 ) ) ;
+ public final void rule__XAndExpression__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5418:1: ( ( ( rule__XAndExpression__Group_1_0__0 ) ) )
+ // InternalOXtype.g:5419:1: ( ( rule__XAndExpression__Group_1_0__0 ) )
+ {
+ // InternalOXtype.g:5419:1: ( ( rule__XAndExpression__Group_1_0__0 ) )
+ // InternalOXtype.g:5420:2: ( rule__XAndExpression__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAndExpressionAccess().getGroup_1_0());
+ }
+ // InternalOXtype.g:5421:2: ( rule__XAndExpression__Group_1_0__0 )
+ // InternalOXtype.g:5421:3: rule__XAndExpression__Group_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAndExpression__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAndExpressionAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAndExpression__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__XAndExpression__Group_1__1"
+ // InternalOXtype.g:5429:1: rule__XAndExpression__Group_1__1 : rule__XAndExpression__Group_1__1__Impl ;
+ public final void rule__XAndExpression__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5433:1: ( rule__XAndExpression__Group_1__1__Impl )
+ // InternalOXtype.g:5434:2: rule__XAndExpression__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAndExpression__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAndExpression__Group_1__1"
+
+
+ // $ANTLR start "rule__XAndExpression__Group_1__1__Impl"
+ // InternalOXtype.g:5440:1: rule__XAndExpression__Group_1__1__Impl : ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) ) ;
+ public final void rule__XAndExpression__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5444:1: ( ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) ) )
+ // InternalOXtype.g:5445:1: ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) )
+ {
+ // InternalOXtype.g:5445:1: ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) )
+ // InternalOXtype.g:5446:2: ( rule__XAndExpression__RightOperandAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1());
+ }
+ // InternalOXtype.g:5447:2: ( rule__XAndExpression__RightOperandAssignment_1_1 )
+ // InternalOXtype.g:5447:3: rule__XAndExpression__RightOperandAssignment_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAndExpression__RightOperandAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAndExpression__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__XAndExpression__Group_1_0__0"
+ // InternalOXtype.g:5456:1: rule__XAndExpression__Group_1_0__0 : rule__XAndExpression__Group_1_0__0__Impl ;
+ public final void rule__XAndExpression__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5460:1: ( rule__XAndExpression__Group_1_0__0__Impl )
+ // InternalOXtype.g:5461:2: rule__XAndExpression__Group_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAndExpression__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAndExpression__Group_1_0__0"
+
+
+ // $ANTLR start "rule__XAndExpression__Group_1_0__0__Impl"
+ // InternalOXtype.g:5467:1: rule__XAndExpression__Group_1_0__0__Impl : ( ( rule__XAndExpression__Group_1_0_0__0 ) ) ;
+ public final void rule__XAndExpression__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5471:1: ( ( ( rule__XAndExpression__Group_1_0_0__0 ) ) )
+ // InternalOXtype.g:5472:1: ( ( rule__XAndExpression__Group_1_0_0__0 ) )
+ {
+ // InternalOXtype.g:5472:1: ( ( rule__XAndExpression__Group_1_0_0__0 ) )
+ // InternalOXtype.g:5473:2: ( rule__XAndExpression__Group_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0());
+ }
+ // InternalOXtype.g:5474:2: ( rule__XAndExpression__Group_1_0_0__0 )
+ // InternalOXtype.g:5474:3: rule__XAndExpression__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAndExpression__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAndExpression__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__XAndExpression__Group_1_0_0__0"
+ // InternalOXtype.g:5483:1: rule__XAndExpression__Group_1_0_0__0 : rule__XAndExpression__Group_1_0_0__0__Impl rule__XAndExpression__Group_1_0_0__1 ;
+ public final void rule__XAndExpression__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5487:1: ( rule__XAndExpression__Group_1_0_0__0__Impl rule__XAndExpression__Group_1_0_0__1 )
+ // InternalOXtype.g:5488:2: rule__XAndExpression__Group_1_0_0__0__Impl rule__XAndExpression__Group_1_0_0__1
+ {
+ pushFollow(FOLLOW_26);
+ rule__XAndExpression__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAndExpression__Group_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAndExpression__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__XAndExpression__Group_1_0_0__0__Impl"
+ // InternalOXtype.g:5495:1: rule__XAndExpression__Group_1_0_0__0__Impl : ( () ) ;
+ public final void rule__XAndExpression__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5499:1: ( ( () ) )
+ // InternalOXtype.g:5500:1: ( () )
+ {
+ // InternalOXtype.g:5500:1: ( () )
+ // InternalOXtype.g:5501:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0());
+ }
+ // InternalOXtype.g:5502:2: ()
+ // InternalOXtype.g:5502:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAndExpression__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XAndExpression__Group_1_0_0__1"
+ // InternalOXtype.g:5510:1: rule__XAndExpression__Group_1_0_0__1 : rule__XAndExpression__Group_1_0_0__1__Impl ;
+ public final void rule__XAndExpression__Group_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5514:1: ( rule__XAndExpression__Group_1_0_0__1__Impl )
+ // InternalOXtype.g:5515:2: rule__XAndExpression__Group_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAndExpression__Group_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAndExpression__Group_1_0_0__1"
+
+
+ // $ANTLR start "rule__XAndExpression__Group_1_0_0__1__Impl"
+ // InternalOXtype.g:5521:1: rule__XAndExpression__Group_1_0_0__1__Impl : ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) ) ;
+ public final void rule__XAndExpression__Group_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5525:1: ( ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) ) )
+ // InternalOXtype.g:5526:1: ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) )
+ {
+ // InternalOXtype.g:5526:1: ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) )
+ // InternalOXtype.g:5527:2: ( rule__XAndExpression__FeatureAssignment_1_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1());
+ }
+ // InternalOXtype.g:5528:2: ( rule__XAndExpression__FeatureAssignment_1_0_0_1 )
+ // InternalOXtype.g:5528:3: rule__XAndExpression__FeatureAssignment_1_0_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAndExpression__FeatureAssignment_1_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAndExpression__Group_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XEqualityExpression__Group__0"
+ // InternalOXtype.g:5537:1: rule__XEqualityExpression__Group__0 : rule__XEqualityExpression__Group__0__Impl rule__XEqualityExpression__Group__1 ;
+ public final void rule__XEqualityExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5541:1: ( rule__XEqualityExpression__Group__0__Impl rule__XEqualityExpression__Group__1 )
+ // InternalOXtype.g:5542:2: rule__XEqualityExpression__Group__0__Impl rule__XEqualityExpression__Group__1
+ {
+ pushFollow(FOLLOW_28);
+ rule__XEqualityExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XEqualityExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XEqualityExpression__Group__0"
+
+
+ // $ANTLR start "rule__XEqualityExpression__Group__0__Impl"
+ // InternalOXtype.g:5549:1: rule__XEqualityExpression__Group__0__Impl : ( ruleXRelationalExpression ) ;
+ public final void rule__XEqualityExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5553:1: ( ( ruleXRelationalExpression ) )
+ // InternalOXtype.g:5554:1: ( ruleXRelationalExpression )
+ {
+ // InternalOXtype.g:5554:1: ( ruleXRelationalExpression )
+ // InternalOXtype.g:5555:2: ruleXRelationalExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXRelationalExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XEqualityExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XEqualityExpression__Group__1"
+ // InternalOXtype.g:5564:1: rule__XEqualityExpression__Group__1 : rule__XEqualityExpression__Group__1__Impl ;
+ public final void rule__XEqualityExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5568:1: ( rule__XEqualityExpression__Group__1__Impl )
+ // InternalOXtype.g:5569:2: rule__XEqualityExpression__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XEqualityExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XEqualityExpression__Group__1"
+
+
+ // $ANTLR start "rule__XEqualityExpression__Group__1__Impl"
+ // InternalOXtype.g:5575:1: rule__XEqualityExpression__Group__1__Impl : ( ( rule__XEqualityExpression__Group_1__0 )* ) ;
+ public final void rule__XEqualityExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5579:1: ( ( ( rule__XEqualityExpression__Group_1__0 )* ) )
+ // InternalOXtype.g:5580:1: ( ( rule__XEqualityExpression__Group_1__0 )* )
+ {
+ // InternalOXtype.g:5580:1: ( ( rule__XEqualityExpression__Group_1__0 )* )
+ // InternalOXtype.g:5581:2: ( rule__XEqualityExpression__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXEqualityExpressionAccess().getGroup_1());
+ }
+ // InternalOXtype.g:5582:2: ( rule__XEqualityExpression__Group_1__0 )*
+ loop60:
+ do {
+ int alt60=2;
+ switch ( input.LA(1) ) {
+ case 21:
+ {
+ int LA60_2 = input.LA(2);
+
+ if ( (synpred104_InternalOXtype()) ) {
+ alt60=1;
+ }
+
+
+ }
+ break;
+ case 22:
+ {
+ int LA60_3 = input.LA(2);
+
+ if ( (synpred104_InternalOXtype()) ) {
+ alt60=1;
+ }
+
+
+ }
+ break;
+ case 23:
+ {
+ int LA60_4 = input.LA(2);
+
+ if ( (synpred104_InternalOXtype()) ) {
+ alt60=1;
+ }
+
+
+ }
+ break;
+ case 24:
+ {
+ int LA60_5 = input.LA(2);
+
+ if ( (synpred104_InternalOXtype()) ) {
+ alt60=1;
+ }
+
+
+ }
+ break;
+
+ }
+
+ switch (alt60) {
+ case 1 :
+ // InternalOXtype.g:5582:3: rule__XEqualityExpression__Group_1__0
+ {
+ pushFollow(FOLLOW_29);
+ rule__XEqualityExpression__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop60;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXEqualityExpressionAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XEqualityExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XEqualityExpression__Group_1__0"
+ // InternalOXtype.g:5591:1: rule__XEqualityExpression__Group_1__0 : rule__XEqualityExpression__Group_1__0__Impl rule__XEqualityExpression__Group_1__1 ;
+ public final void rule__XEqualityExpression__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5595:1: ( rule__XEqualityExpression__Group_1__0__Impl rule__XEqualityExpression__Group_1__1 )
+ // InternalOXtype.g:5596:2: rule__XEqualityExpression__Group_1__0__Impl rule__XEqualityExpression__Group_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XEqualityExpression__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XEqualityExpression__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XEqualityExpression__Group_1__0"
+
+
+ // $ANTLR start "rule__XEqualityExpression__Group_1__0__Impl"
+ // InternalOXtype.g:5603:1: rule__XEqualityExpression__Group_1__0__Impl : ( ( rule__XEqualityExpression__Group_1_0__0 ) ) ;
+ public final void rule__XEqualityExpression__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5607:1: ( ( ( rule__XEqualityExpression__Group_1_0__0 ) ) )
+ // InternalOXtype.g:5608:1: ( ( rule__XEqualityExpression__Group_1_0__0 ) )
+ {
+ // InternalOXtype.g:5608:1: ( ( rule__XEqualityExpression__Group_1_0__0 ) )
+ // InternalOXtype.g:5609:2: ( rule__XEqualityExpression__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0());
+ }
+ // InternalOXtype.g:5610:2: ( rule__XEqualityExpression__Group_1_0__0 )
+ // InternalOXtype.g:5610:3: rule__XEqualityExpression__Group_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XEqualityExpression__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XEqualityExpression__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__XEqualityExpression__Group_1__1"
+ // InternalOXtype.g:5618:1: rule__XEqualityExpression__Group_1__1 : rule__XEqualityExpression__Group_1__1__Impl ;
+ public final void rule__XEqualityExpression__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5622:1: ( rule__XEqualityExpression__Group_1__1__Impl )
+ // InternalOXtype.g:5623:2: rule__XEqualityExpression__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XEqualityExpression__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XEqualityExpression__Group_1__1"
+
+
+ // $ANTLR start "rule__XEqualityExpression__Group_1__1__Impl"
+ // InternalOXtype.g:5629:1: rule__XEqualityExpression__Group_1__1__Impl : ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) ) ;
+ public final void rule__XEqualityExpression__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5633:1: ( ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) ) )
+ // InternalOXtype.g:5634:1: ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) )
+ {
+ // InternalOXtype.g:5634:1: ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) )
+ // InternalOXtype.g:5635:2: ( rule__XEqualityExpression__RightOperandAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1());
+ }
+ // InternalOXtype.g:5636:2: ( rule__XEqualityExpression__RightOperandAssignment_1_1 )
+ // InternalOXtype.g:5636:3: rule__XEqualityExpression__RightOperandAssignment_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XEqualityExpression__RightOperandAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XEqualityExpression__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__XEqualityExpression__Group_1_0__0"
+ // InternalOXtype.g:5645:1: rule__XEqualityExpression__Group_1_0__0 : rule__XEqualityExpression__Group_1_0__0__Impl ;
+ public final void rule__XEqualityExpression__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5649:1: ( rule__XEqualityExpression__Group_1_0__0__Impl )
+ // InternalOXtype.g:5650:2: rule__XEqualityExpression__Group_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XEqualityExpression__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XEqualityExpression__Group_1_0__0"
+
+
+ // $ANTLR start "rule__XEqualityExpression__Group_1_0__0__Impl"
+ // InternalOXtype.g:5656:1: rule__XEqualityExpression__Group_1_0__0__Impl : ( ( rule__XEqualityExpression__Group_1_0_0__0 ) ) ;
+ public final void rule__XEqualityExpression__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5660:1: ( ( ( rule__XEqualityExpression__Group_1_0_0__0 ) ) )
+ // InternalOXtype.g:5661:1: ( ( rule__XEqualityExpression__Group_1_0_0__0 ) )
+ {
+ // InternalOXtype.g:5661:1: ( ( rule__XEqualityExpression__Group_1_0_0__0 ) )
+ // InternalOXtype.g:5662:2: ( rule__XEqualityExpression__Group_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0());
+ }
+ // InternalOXtype.g:5663:2: ( rule__XEqualityExpression__Group_1_0_0__0 )
+ // InternalOXtype.g:5663:3: rule__XEqualityExpression__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XEqualityExpression__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XEqualityExpression__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__0"
+ // InternalOXtype.g:5672:1: rule__XEqualityExpression__Group_1_0_0__0 : rule__XEqualityExpression__Group_1_0_0__0__Impl rule__XEqualityExpression__Group_1_0_0__1 ;
+ public final void rule__XEqualityExpression__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5676:1: ( rule__XEqualityExpression__Group_1_0_0__0__Impl rule__XEqualityExpression__Group_1_0_0__1 )
+ // InternalOXtype.g:5677:2: rule__XEqualityExpression__Group_1_0_0__0__Impl rule__XEqualityExpression__Group_1_0_0__1
+ {
+ pushFollow(FOLLOW_28);
+ rule__XEqualityExpression__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XEqualityExpression__Group_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__0__Impl"
+ // InternalOXtype.g:5684:1: rule__XEqualityExpression__Group_1_0_0__0__Impl : ( () ) ;
+ public final void rule__XEqualityExpression__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5688:1: ( ( () ) )
+ // InternalOXtype.g:5689:1: ( () )
+ {
+ // InternalOXtype.g:5689:1: ( () )
+ // InternalOXtype.g:5690:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0());
+ }
+ // InternalOXtype.g:5691:2: ()
+ // InternalOXtype.g:5691:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__1"
+ // InternalOXtype.g:5699:1: rule__XEqualityExpression__Group_1_0_0__1 : rule__XEqualityExpression__Group_1_0_0__1__Impl ;
+ public final void rule__XEqualityExpression__Group_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5703:1: ( rule__XEqualityExpression__Group_1_0_0__1__Impl )
+ // InternalOXtype.g:5704:2: rule__XEqualityExpression__Group_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XEqualityExpression__Group_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__1"
+
+
+ // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__1__Impl"
+ // InternalOXtype.g:5710:1: rule__XEqualityExpression__Group_1_0_0__1__Impl : ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) ) ;
+ public final void rule__XEqualityExpression__Group_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5714:1: ( ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) ) )
+ // InternalOXtype.g:5715:1: ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) )
+ {
+ // InternalOXtype.g:5715:1: ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) )
+ // InternalOXtype.g:5716:2: ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1());
+ }
+ // InternalOXtype.g:5717:2: ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 )
+ // InternalOXtype.g:5717:3: rule__XEqualityExpression__FeatureAssignment_1_0_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XEqualityExpression__FeatureAssignment_1_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group__0"
+ // InternalOXtype.g:5726:1: rule__XRelationalExpression__Group__0 : rule__XRelationalExpression__Group__0__Impl rule__XRelationalExpression__Group__1 ;
+ public final void rule__XRelationalExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5730:1: ( rule__XRelationalExpression__Group__0__Impl rule__XRelationalExpression__Group__1 )
+ // InternalOXtype.g:5731:2: rule__XRelationalExpression__Group__0__Impl rule__XRelationalExpression__Group__1
+ {
+ pushFollow(FOLLOW_30);
+ rule__XRelationalExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group__0"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group__0__Impl"
+ // InternalOXtype.g:5738:1: rule__XRelationalExpression__Group__0__Impl : ( ruleXOtherOperatorExpression ) ;
+ public final void rule__XRelationalExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5742:1: ( ( ruleXOtherOperatorExpression ) )
+ // InternalOXtype.g:5743:1: ( ruleXOtherOperatorExpression )
+ {
+ // InternalOXtype.g:5743:1: ( ruleXOtherOperatorExpression )
+ // InternalOXtype.g:5744:2: ruleXOtherOperatorExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXOtherOperatorExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group__1"
+ // InternalOXtype.g:5753:1: rule__XRelationalExpression__Group__1 : rule__XRelationalExpression__Group__1__Impl ;
+ public final void rule__XRelationalExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5757:1: ( rule__XRelationalExpression__Group__1__Impl )
+ // InternalOXtype.g:5758:2: rule__XRelationalExpression__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group__1"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group__1__Impl"
+ // InternalOXtype.g:5764:1: rule__XRelationalExpression__Group__1__Impl : ( ( rule__XRelationalExpression__Alternatives_1 )* ) ;
+ public final void rule__XRelationalExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5768:1: ( ( ( rule__XRelationalExpression__Alternatives_1 )* ) )
+ // InternalOXtype.g:5769:1: ( ( rule__XRelationalExpression__Alternatives_1 )* )
+ {
+ // InternalOXtype.g:5769:1: ( ( rule__XRelationalExpression__Alternatives_1 )* )
+ // InternalOXtype.g:5770:2: ( rule__XRelationalExpression__Alternatives_1 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1());
+ }
+ // InternalOXtype.g:5771:2: ( rule__XRelationalExpression__Alternatives_1 )*
+ loop61:
+ do {
+ int alt61=2;
+ switch ( input.LA(1) ) {
+ case 27:
+ {
+ int LA61_2 = input.LA(2);
+
+ if ( (synpred105_InternalOXtype()) ) {
+ alt61=1;
+ }
+
+
+ }
+ break;
+ case 26:
+ {
+ int LA61_3 = input.LA(2);
+
+ if ( (synpred105_InternalOXtype()) ) {
+ alt61=1;
+ }
+
+
+ }
+ break;
+ case 59:
+ {
+ int LA61_4 = input.LA(2);
+
+ if ( (synpred105_InternalOXtype()) ) {
+ alt61=1;
+ }
+
+
+ }
+ break;
+ case 25:
+ {
+ int LA61_5 = input.LA(2);
+
+ if ( (synpred105_InternalOXtype()) ) {
+ alt61=1;
+ }
+
+
+ }
+ break;
+
+ }
+
+ switch (alt61) {
+ case 1 :
+ // InternalOXtype.g:5771:3: rule__XRelationalExpression__Alternatives_1
+ {
+ pushFollow(FOLLOW_31);
+ rule__XRelationalExpression__Alternatives_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop61;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_0__0"
+ // InternalOXtype.g:5780:1: rule__XRelationalExpression__Group_1_0__0 : rule__XRelationalExpression__Group_1_0__0__Impl rule__XRelationalExpression__Group_1_0__1 ;
+ public final void rule__XRelationalExpression__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5784:1: ( rule__XRelationalExpression__Group_1_0__0__Impl rule__XRelationalExpression__Group_1_0__1 )
+ // InternalOXtype.g:5785:2: rule__XRelationalExpression__Group_1_0__0__Impl rule__XRelationalExpression__Group_1_0__1
+ {
+ pushFollow(FOLLOW_32);
+ rule__XRelationalExpression__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group_1_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_0__0"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_0__0__Impl"
+ // InternalOXtype.g:5792:1: rule__XRelationalExpression__Group_1_0__0__Impl : ( ( rule__XRelationalExpression__Group_1_0_0__0 ) ) ;
+ public final void rule__XRelationalExpression__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5796:1: ( ( ( rule__XRelationalExpression__Group_1_0_0__0 ) ) )
+ // InternalOXtype.g:5797:1: ( ( rule__XRelationalExpression__Group_1_0_0__0 ) )
+ {
+ // InternalOXtype.g:5797:1: ( ( rule__XRelationalExpression__Group_1_0_0__0 ) )
+ // InternalOXtype.g:5798:2: ( rule__XRelationalExpression__Group_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0());
+ }
+ // InternalOXtype.g:5799:2: ( rule__XRelationalExpression__Group_1_0_0__0 )
+ // InternalOXtype.g:5799:3: rule__XRelationalExpression__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_0__1"
+ // InternalOXtype.g:5807:1: rule__XRelationalExpression__Group_1_0__1 : rule__XRelationalExpression__Group_1_0__1__Impl ;
+ public final void rule__XRelationalExpression__Group_1_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5811:1: ( rule__XRelationalExpression__Group_1_0__1__Impl )
+ // InternalOXtype.g:5812:2: rule__XRelationalExpression__Group_1_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group_1_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_0__1"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_0__1__Impl"
+ // InternalOXtype.g:5818:1: rule__XRelationalExpression__Group_1_0__1__Impl : ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) ) ;
+ public final void rule__XRelationalExpression__Group_1_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5822:1: ( ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) ) )
+ // InternalOXtype.g:5823:1: ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) )
+ {
+ // InternalOXtype.g:5823:1: ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) )
+ // InternalOXtype.g:5824:2: ( rule__XRelationalExpression__TypeAssignment_1_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1());
+ }
+ // InternalOXtype.g:5825:2: ( rule__XRelationalExpression__TypeAssignment_1_0_1 )
+ // InternalOXtype.g:5825:3: rule__XRelationalExpression__TypeAssignment_1_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__TypeAssignment_1_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_0__1__Impl"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_0_0__0"
+ // InternalOXtype.g:5834:1: rule__XRelationalExpression__Group_1_0_0__0 : rule__XRelationalExpression__Group_1_0_0__0__Impl ;
+ public final void rule__XRelationalExpression__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5838:1: ( rule__XRelationalExpression__Group_1_0_0__0__Impl )
+ // InternalOXtype.g:5839:2: rule__XRelationalExpression__Group_1_0_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_0_0__0__Impl"
+ // InternalOXtype.g:5845:1: rule__XRelationalExpression__Group_1_0_0__0__Impl : ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) ) ;
+ public final void rule__XRelationalExpression__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5849:1: ( ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) ) )
+ // InternalOXtype.g:5850:1: ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) )
+ {
+ // InternalOXtype.g:5850:1: ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) )
+ // InternalOXtype.g:5851:2: ( rule__XRelationalExpression__Group_1_0_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0());
+ }
+ // InternalOXtype.g:5852:2: ( rule__XRelationalExpression__Group_1_0_0_0__0 )
+ // InternalOXtype.g:5852:3: rule__XRelationalExpression__Group_1_0_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group_1_0_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__0"
+ // InternalOXtype.g:5861:1: rule__XRelationalExpression__Group_1_0_0_0__0 : rule__XRelationalExpression__Group_1_0_0_0__0__Impl rule__XRelationalExpression__Group_1_0_0_0__1 ;
+ public final void rule__XRelationalExpression__Group_1_0_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5865:1: ( rule__XRelationalExpression__Group_1_0_0_0__0__Impl rule__XRelationalExpression__Group_1_0_0_0__1 )
+ // InternalOXtype.g:5866:2: rule__XRelationalExpression__Group_1_0_0_0__0__Impl rule__XRelationalExpression__Group_1_0_0_0__1
+ {
+ pushFollow(FOLLOW_33);
+ rule__XRelationalExpression__Group_1_0_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group_1_0_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__0"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__0__Impl"
+ // InternalOXtype.g:5873:1: rule__XRelationalExpression__Group_1_0_0_0__0__Impl : ( () ) ;
+ public final void rule__XRelationalExpression__Group_1_0_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5877:1: ( ( () ) )
+ // InternalOXtype.g:5878:1: ( () )
+ {
+ // InternalOXtype.g:5878:1: ( () )
+ // InternalOXtype.g:5879:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0());
+ }
+ // InternalOXtype.g:5880:2: ()
+ // InternalOXtype.g:5880:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__1"
+ // InternalOXtype.g:5888:1: rule__XRelationalExpression__Group_1_0_0_0__1 : rule__XRelationalExpression__Group_1_0_0_0__1__Impl ;
+ public final void rule__XRelationalExpression__Group_1_0_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5892:1: ( rule__XRelationalExpression__Group_1_0_0_0__1__Impl )
+ // InternalOXtype.g:5893:2: rule__XRelationalExpression__Group_1_0_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group_1_0_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__1"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__1__Impl"
+ // InternalOXtype.g:5899:1: rule__XRelationalExpression__Group_1_0_0_0__1__Impl : ( 'instanceof' ) ;
+ public final void rule__XRelationalExpression__Group_1_0_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5903:1: ( ( 'instanceof' ) )
+ // InternalOXtype.g:5904:1: ( 'instanceof' )
+ {
+ // InternalOXtype.g:5904:1: ( 'instanceof' )
+ // InternalOXtype.g:5905:2: 'instanceof'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1());
+ }
+ match(input,59,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_1__0"
+ // InternalOXtype.g:5915:1: rule__XRelationalExpression__Group_1_1__0 : rule__XRelationalExpression__Group_1_1__0__Impl rule__XRelationalExpression__Group_1_1__1 ;
+ public final void rule__XRelationalExpression__Group_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5919:1: ( rule__XRelationalExpression__Group_1_1__0__Impl rule__XRelationalExpression__Group_1_1__1 )
+ // InternalOXtype.g:5920:2: rule__XRelationalExpression__Group_1_1__0__Impl rule__XRelationalExpression__Group_1_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XRelationalExpression__Group_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_1__0"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_1__0__Impl"
+ // InternalOXtype.g:5927:1: rule__XRelationalExpression__Group_1_1__0__Impl : ( ( rule__XRelationalExpression__Group_1_1_0__0 ) ) ;
+ public final void rule__XRelationalExpression__Group_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5931:1: ( ( ( rule__XRelationalExpression__Group_1_1_0__0 ) ) )
+ // InternalOXtype.g:5932:1: ( ( rule__XRelationalExpression__Group_1_1_0__0 ) )
+ {
+ // InternalOXtype.g:5932:1: ( ( rule__XRelationalExpression__Group_1_1_0__0 ) )
+ // InternalOXtype.g:5933:2: ( rule__XRelationalExpression__Group_1_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0());
+ }
+ // InternalOXtype.g:5934:2: ( rule__XRelationalExpression__Group_1_1_0__0 )
+ // InternalOXtype.g:5934:3: rule__XRelationalExpression__Group_1_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group_1_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_1__1"
+ // InternalOXtype.g:5942:1: rule__XRelationalExpression__Group_1_1__1 : rule__XRelationalExpression__Group_1_1__1__Impl ;
+ public final void rule__XRelationalExpression__Group_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5946:1: ( rule__XRelationalExpression__Group_1_1__1__Impl )
+ // InternalOXtype.g:5947:2: rule__XRelationalExpression__Group_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_1__1"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_1__1__Impl"
+ // InternalOXtype.g:5953:1: rule__XRelationalExpression__Group_1_1__1__Impl : ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) ) ;
+ public final void rule__XRelationalExpression__Group_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5957:1: ( ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) ) )
+ // InternalOXtype.g:5958:1: ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) )
+ {
+ // InternalOXtype.g:5958:1: ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) )
+ // InternalOXtype.g:5959:2: ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1());
+ }
+ // InternalOXtype.g:5960:2: ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 )
+ // InternalOXtype.g:5960:3: rule__XRelationalExpression__RightOperandAssignment_1_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__RightOperandAssignment_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_1_0__0"
+ // InternalOXtype.g:5969:1: rule__XRelationalExpression__Group_1_1_0__0 : rule__XRelationalExpression__Group_1_1_0__0__Impl ;
+ public final void rule__XRelationalExpression__Group_1_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5973:1: ( rule__XRelationalExpression__Group_1_1_0__0__Impl )
+ // InternalOXtype.g:5974:2: rule__XRelationalExpression__Group_1_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group_1_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_1_0__0"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_1_0__0__Impl"
+ // InternalOXtype.g:5980:1: rule__XRelationalExpression__Group_1_1_0__0__Impl : ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) ) ;
+ public final void rule__XRelationalExpression__Group_1_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:5984:1: ( ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) ) )
+ // InternalOXtype.g:5985:1: ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) )
+ {
+ // InternalOXtype.g:5985:1: ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) )
+ // InternalOXtype.g:5986:2: ( rule__XRelationalExpression__Group_1_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0());
+ }
+ // InternalOXtype.g:5987:2: ( rule__XRelationalExpression__Group_1_1_0_0__0 )
+ // InternalOXtype.g:5987:3: rule__XRelationalExpression__Group_1_1_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group_1_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__0"
+ // InternalOXtype.g:5996:1: rule__XRelationalExpression__Group_1_1_0_0__0 : rule__XRelationalExpression__Group_1_1_0_0__0__Impl rule__XRelationalExpression__Group_1_1_0_0__1 ;
+ public final void rule__XRelationalExpression__Group_1_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6000:1: ( rule__XRelationalExpression__Group_1_1_0_0__0__Impl rule__XRelationalExpression__Group_1_1_0_0__1 )
+ // InternalOXtype.g:6001:2: rule__XRelationalExpression__Group_1_1_0_0__0__Impl rule__XRelationalExpression__Group_1_1_0_0__1
+ {
+ pushFollow(FOLLOW_30);
+ rule__XRelationalExpression__Group_1_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group_1_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__0"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__0__Impl"
+ // InternalOXtype.g:6008:1: rule__XRelationalExpression__Group_1_1_0_0__0__Impl : ( () ) ;
+ public final void rule__XRelationalExpression__Group_1_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6012:1: ( ( () ) )
+ // InternalOXtype.g:6013:1: ( () )
+ {
+ // InternalOXtype.g:6013:1: ( () )
+ // InternalOXtype.g:6014:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0());
+ }
+ // InternalOXtype.g:6015:2: ()
+ // InternalOXtype.g:6015:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__1"
+ // InternalOXtype.g:6023:1: rule__XRelationalExpression__Group_1_1_0_0__1 : rule__XRelationalExpression__Group_1_1_0_0__1__Impl ;
+ public final void rule__XRelationalExpression__Group_1_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6027:1: ( rule__XRelationalExpression__Group_1_1_0_0__1__Impl )
+ // InternalOXtype.g:6028:2: rule__XRelationalExpression__Group_1_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Group_1_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__1"
+
+
+ // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__1__Impl"
+ // InternalOXtype.g:6034:1: rule__XRelationalExpression__Group_1_1_0_0__1__Impl : ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) ) ;
+ public final void rule__XRelationalExpression__Group_1_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6038:1: ( ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) ) )
+ // InternalOXtype.g:6039:1: ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) )
+ {
+ // InternalOXtype.g:6039:1: ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) )
+ // InternalOXtype.g:6040:2: ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1());
+ }
+ // InternalOXtype.g:6041:2: ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 )
+ // InternalOXtype.g:6041:3: rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__OpCompare__Group_1__0"
+ // InternalOXtype.g:6050:1: rule__OpCompare__Group_1__0 : rule__OpCompare__Group_1__0__Impl rule__OpCompare__Group_1__1 ;
+ public final void rule__OpCompare__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6054:1: ( rule__OpCompare__Group_1__0__Impl rule__OpCompare__Group_1__1 )
+ // InternalOXtype.g:6055:2: rule__OpCompare__Group_1__0__Impl rule__OpCompare__Group_1__1
+ {
+ pushFollow(FOLLOW_16);
+ rule__OpCompare__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__OpCompare__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpCompare__Group_1__0"
+
+
+ // $ANTLR start "rule__OpCompare__Group_1__0__Impl"
+ // InternalOXtype.g:6062:1: rule__OpCompare__Group_1__0__Impl : ( '<' ) ;
+ public final void rule__OpCompare__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6066:1: ( ( '<' ) )
+ // InternalOXtype.g:6067:1: ( '<' )
+ {
+ // InternalOXtype.g:6067:1: ( '<' )
+ // InternalOXtype.g:6068:2: '<'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0());
+ }
+ match(input,27,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpCompare__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__OpCompare__Group_1__1"
+ // InternalOXtype.g:6077:1: rule__OpCompare__Group_1__1 : rule__OpCompare__Group_1__1__Impl ;
+ public final void rule__OpCompare__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6081:1: ( rule__OpCompare__Group_1__1__Impl )
+ // InternalOXtype.g:6082:2: rule__OpCompare__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpCompare__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpCompare__Group_1__1"
+
+
+ // $ANTLR start "rule__OpCompare__Group_1__1__Impl"
+ // InternalOXtype.g:6088:1: rule__OpCompare__Group_1__1__Impl : ( '=' ) ;
+ public final void rule__OpCompare__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6092:1: ( ( '=' ) )
+ // InternalOXtype.g:6093:1: ( '=' )
+ {
+ // InternalOXtype.g:6093:1: ( '=' )
+ // InternalOXtype.g:6094:2: '='
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1());
+ }
+ match(input,13,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpCompare__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__XOtherOperatorExpression__Group__0"
+ // InternalOXtype.g:6104:1: rule__XOtherOperatorExpression__Group__0 : rule__XOtherOperatorExpression__Group__0__Impl rule__XOtherOperatorExpression__Group__1 ;
+ public final void rule__XOtherOperatorExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6108:1: ( rule__XOtherOperatorExpression__Group__0__Impl rule__XOtherOperatorExpression__Group__1 )
+ // InternalOXtype.g:6109:2: rule__XOtherOperatorExpression__Group__0__Impl rule__XOtherOperatorExpression__Group__1
+ {
+ pushFollow(FOLLOW_34);
+ rule__XOtherOperatorExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XOtherOperatorExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOtherOperatorExpression__Group__0"
+
+
+ // $ANTLR start "rule__XOtherOperatorExpression__Group__0__Impl"
+ // InternalOXtype.g:6116:1: rule__XOtherOperatorExpression__Group__0__Impl : ( ruleXAdditiveExpression ) ;
+ public final void rule__XOtherOperatorExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6120:1: ( ( ruleXAdditiveExpression ) )
+ // InternalOXtype.g:6121:1: ( ruleXAdditiveExpression )
+ {
+ // InternalOXtype.g:6121:1: ( ruleXAdditiveExpression )
+ // InternalOXtype.g:6122:2: ruleXAdditiveExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAdditiveExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOtherOperatorExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XOtherOperatorExpression__Group__1"
+ // InternalOXtype.g:6131:1: rule__XOtherOperatorExpression__Group__1 : rule__XOtherOperatorExpression__Group__1__Impl ;
+ public final void rule__XOtherOperatorExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6135:1: ( rule__XOtherOperatorExpression__Group__1__Impl )
+ // InternalOXtype.g:6136:2: rule__XOtherOperatorExpression__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOtherOperatorExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOtherOperatorExpression__Group__1"
+
+
+ // $ANTLR start "rule__XOtherOperatorExpression__Group__1__Impl"
+ // InternalOXtype.g:6142:1: rule__XOtherOperatorExpression__Group__1__Impl : ( ( rule__XOtherOperatorExpression__Group_1__0 )* ) ;
+ public final void rule__XOtherOperatorExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6146:1: ( ( ( rule__XOtherOperatorExpression__Group_1__0 )* ) )
+ // InternalOXtype.g:6147:1: ( ( rule__XOtherOperatorExpression__Group_1__0 )* )
+ {
+ // InternalOXtype.g:6147:1: ( ( rule__XOtherOperatorExpression__Group_1__0 )* )
+ // InternalOXtype.g:6148:2: ( rule__XOtherOperatorExpression__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1());
+ }
+ // InternalOXtype.g:6149:2: ( rule__XOtherOperatorExpression__Group_1__0 )*
+ loop62:
+ do {
+ int alt62=2;
+ alt62 = dfa62.predict(input);
+ switch (alt62) {
+ case 1 :
+ // InternalOXtype.g:6149:3: rule__XOtherOperatorExpression__Group_1__0
+ {
+ pushFollow(FOLLOW_35);
+ rule__XOtherOperatorExpression__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop62;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOtherOperatorExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XOtherOperatorExpression__Group_1__0"
+ // InternalOXtype.g:6158:1: rule__XOtherOperatorExpression__Group_1__0 : rule__XOtherOperatorExpression__Group_1__0__Impl rule__XOtherOperatorExpression__Group_1__1 ;
+ public final void rule__XOtherOperatorExpression__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6162:1: ( rule__XOtherOperatorExpression__Group_1__0__Impl rule__XOtherOperatorExpression__Group_1__1 )
+ // InternalOXtype.g:6163:2: rule__XOtherOperatorExpression__Group_1__0__Impl rule__XOtherOperatorExpression__Group_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XOtherOperatorExpression__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XOtherOperatorExpression__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOtherOperatorExpression__Group_1__0"
+
+
+ // $ANTLR start "rule__XOtherOperatorExpression__Group_1__0__Impl"
+ // InternalOXtype.g:6170:1: rule__XOtherOperatorExpression__Group_1__0__Impl : ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) ) ;
+ public final void rule__XOtherOperatorExpression__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6174:1: ( ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) ) )
+ // InternalOXtype.g:6175:1: ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) )
+ {
+ // InternalOXtype.g:6175:1: ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) )
+ // InternalOXtype.g:6176:2: ( rule__XOtherOperatorExpression__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0());
+ }
+ // InternalOXtype.g:6177:2: ( rule__XOtherOperatorExpression__Group_1_0__0 )
+ // InternalOXtype.g:6177:3: rule__XOtherOperatorExpression__Group_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOtherOperatorExpression__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOtherOperatorExpression__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__XOtherOperatorExpression__Group_1__1"
+ // InternalOXtype.g:6185:1: rule__XOtherOperatorExpression__Group_1__1 : rule__XOtherOperatorExpression__Group_1__1__Impl ;
+ public final void rule__XOtherOperatorExpression__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6189:1: ( rule__XOtherOperatorExpression__Group_1__1__Impl )
+ // InternalOXtype.g:6190:2: rule__XOtherOperatorExpression__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOtherOperatorExpression__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOtherOperatorExpression__Group_1__1"
+
+
+ // $ANTLR start "rule__XOtherOperatorExpression__Group_1__1__Impl"
+ // InternalOXtype.g:6196:1: rule__XOtherOperatorExpression__Group_1__1__Impl : ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) ) ;
+ public final void rule__XOtherOperatorExpression__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6200:1: ( ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) ) )
+ // InternalOXtype.g:6201:1: ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) )
+ {
+ // InternalOXtype.g:6201:1: ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) )
+ // InternalOXtype.g:6202:2: ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1());
+ }
+ // InternalOXtype.g:6203:2: ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 )
+ // InternalOXtype.g:6203:3: rule__XOtherOperatorExpression__RightOperandAssignment_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOtherOperatorExpression__RightOperandAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOtherOperatorExpression__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0__0"
+ // InternalOXtype.g:6212:1: rule__XOtherOperatorExpression__Group_1_0__0 : rule__XOtherOperatorExpression__Group_1_0__0__Impl ;
+ public final void rule__XOtherOperatorExpression__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6216:1: ( rule__XOtherOperatorExpression__Group_1_0__0__Impl )
+ // InternalOXtype.g:6217:2: rule__XOtherOperatorExpression__Group_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOtherOperatorExpression__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0__0"
+
+
+ // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0__0__Impl"
+ // InternalOXtype.g:6223:1: rule__XOtherOperatorExpression__Group_1_0__0__Impl : ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) ) ;
+ public final void rule__XOtherOperatorExpression__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6227:1: ( ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) ) )
+ // InternalOXtype.g:6228:1: ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) )
+ {
+ // InternalOXtype.g:6228:1: ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) )
+ // InternalOXtype.g:6229:2: ( rule__XOtherOperatorExpression__Group_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0());
+ }
+ // InternalOXtype.g:6230:2: ( rule__XOtherOperatorExpression__Group_1_0_0__0 )
+ // InternalOXtype.g:6230:3: rule__XOtherOperatorExpression__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOtherOperatorExpression__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__0"
+ // InternalOXtype.g:6239:1: rule__XOtherOperatorExpression__Group_1_0_0__0 : rule__XOtherOperatorExpression__Group_1_0_0__0__Impl rule__XOtherOperatorExpression__Group_1_0_0__1 ;
+ public final void rule__XOtherOperatorExpression__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6243:1: ( rule__XOtherOperatorExpression__Group_1_0_0__0__Impl rule__XOtherOperatorExpression__Group_1_0_0__1 )
+ // InternalOXtype.g:6244:2: rule__XOtherOperatorExpression__Group_1_0_0__0__Impl rule__XOtherOperatorExpression__Group_1_0_0__1
+ {
+ pushFollow(FOLLOW_34);
+ rule__XOtherOperatorExpression__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XOtherOperatorExpression__Group_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__0__Impl"
+ // InternalOXtype.g:6251:1: rule__XOtherOperatorExpression__Group_1_0_0__0__Impl : ( () ) ;
+ public final void rule__XOtherOperatorExpression__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6255:1: ( ( () ) )
+ // InternalOXtype.g:6256:1: ( () )
+ {
+ // InternalOXtype.g:6256:1: ( () )
+ // InternalOXtype.g:6257:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0());
+ }
+ // InternalOXtype.g:6258:2: ()
+ // InternalOXtype.g:6258:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__1"
+ // InternalOXtype.g:6266:1: rule__XOtherOperatorExpression__Group_1_0_0__1 : rule__XOtherOperatorExpression__Group_1_0_0__1__Impl ;
+ public final void rule__XOtherOperatorExpression__Group_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6270:1: ( rule__XOtherOperatorExpression__Group_1_0_0__1__Impl )
+ // InternalOXtype.g:6271:2: rule__XOtherOperatorExpression__Group_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOtherOperatorExpression__Group_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__1"
+
+
+ // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__1__Impl"
+ // InternalOXtype.g:6277:1: rule__XOtherOperatorExpression__Group_1_0_0__1__Impl : ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) ) ;
+ public final void rule__XOtherOperatorExpression__Group_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6281:1: ( ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) ) )
+ // InternalOXtype.g:6282:1: ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) )
+ {
+ // InternalOXtype.g:6282:1: ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) )
+ // InternalOXtype.g:6283:2: ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1());
+ }
+ // InternalOXtype.g:6284:2: ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 )
+ // InternalOXtype.g:6284:3: rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__OpOther__Group_2__0"
+ // InternalOXtype.g:6293:1: rule__OpOther__Group_2__0 : rule__OpOther__Group_2__0__Impl rule__OpOther__Group_2__1 ;
+ public final void rule__OpOther__Group_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6297:1: ( rule__OpOther__Group_2__0__Impl rule__OpOther__Group_2__1 )
+ // InternalOXtype.g:6298:2: rule__OpOther__Group_2__0__Impl rule__OpOther__Group_2__1
+ {
+ pushFollow(FOLLOW_36);
+ rule__OpOther__Group_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_2__0"
+
+
+ // $ANTLR start "rule__OpOther__Group_2__0__Impl"
+ // InternalOXtype.g:6305:1: rule__OpOther__Group_2__0__Impl : ( '>' ) ;
+ public final void rule__OpOther__Group_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6309:1: ( ( '>' ) )
+ // InternalOXtype.g:6310:1: ( '>' )
+ {
+ // InternalOXtype.g:6310:1: ( '>' )
+ // InternalOXtype.g:6311:2: '>'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0());
+ }
+ match(input,26,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_2__0__Impl"
+
+
+ // $ANTLR start "rule__OpOther__Group_2__1"
+ // InternalOXtype.g:6320:1: rule__OpOther__Group_2__1 : rule__OpOther__Group_2__1__Impl ;
+ public final void rule__OpOther__Group_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6324:1: ( rule__OpOther__Group_2__1__Impl )
+ // InternalOXtype.g:6325:2: rule__OpOther__Group_2__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_2__1"
+
+
+ // $ANTLR start "rule__OpOther__Group_2__1__Impl"
+ // InternalOXtype.g:6331:1: rule__OpOther__Group_2__1__Impl : ( '..' ) ;
+ public final void rule__OpOther__Group_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6335:1: ( ( '..' ) )
+ // InternalOXtype.g:6336:1: ( '..' )
+ {
+ // InternalOXtype.g:6336:1: ( '..' )
+ // InternalOXtype.g:6337:2: '..'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1());
+ }
+ match(input,30,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_2__1__Impl"
+
+
+ // $ANTLR start "rule__OpOther__Group_5__0"
+ // InternalOXtype.g:6347:1: rule__OpOther__Group_5__0 : rule__OpOther__Group_5__0__Impl rule__OpOther__Group_5__1 ;
+ public final void rule__OpOther__Group_5__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6351:1: ( rule__OpOther__Group_5__0__Impl rule__OpOther__Group_5__1 )
+ // InternalOXtype.g:6352:2: rule__OpOther__Group_5__0__Impl rule__OpOther__Group_5__1
+ {
+ pushFollow(FOLLOW_37);
+ rule__OpOther__Group_5__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_5__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_5__0"
+
+
+ // $ANTLR start "rule__OpOther__Group_5__0__Impl"
+ // InternalOXtype.g:6359:1: rule__OpOther__Group_5__0__Impl : ( '>' ) ;
+ public final void rule__OpOther__Group_5__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6363:1: ( ( '>' ) )
+ // InternalOXtype.g:6364:1: ( '>' )
+ {
+ // InternalOXtype.g:6364:1: ( '>' )
+ // InternalOXtype.g:6365:2: '>'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0());
+ }
+ match(input,26,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_5__0__Impl"
+
+
+ // $ANTLR start "rule__OpOther__Group_5__1"
+ // InternalOXtype.g:6374:1: rule__OpOther__Group_5__1 : rule__OpOther__Group_5__1__Impl ;
+ public final void rule__OpOther__Group_5__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6378:1: ( rule__OpOther__Group_5__1__Impl )
+ // InternalOXtype.g:6379:2: rule__OpOther__Group_5__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_5__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_5__1"
+
+
+ // $ANTLR start "rule__OpOther__Group_5__1__Impl"
+ // InternalOXtype.g:6385:1: rule__OpOther__Group_5__1__Impl : ( ( rule__OpOther__Alternatives_5_1 ) ) ;
+ public final void rule__OpOther__Group_5__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6389:1: ( ( ( rule__OpOther__Alternatives_5_1 ) ) )
+ // InternalOXtype.g:6390:1: ( ( rule__OpOther__Alternatives_5_1 ) )
+ {
+ // InternalOXtype.g:6390:1: ( ( rule__OpOther__Alternatives_5_1 ) )
+ // InternalOXtype.g:6391:2: ( rule__OpOther__Alternatives_5_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getAlternatives_5_1());
+ }
+ // InternalOXtype.g:6392:2: ( rule__OpOther__Alternatives_5_1 )
+ // InternalOXtype.g:6392:3: rule__OpOther__Alternatives_5_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Alternatives_5_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getAlternatives_5_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_5__1__Impl"
+
+
+ // $ANTLR start "rule__OpOther__Group_5_1_0__0"
+ // InternalOXtype.g:6401:1: rule__OpOther__Group_5_1_0__0 : rule__OpOther__Group_5_1_0__0__Impl ;
+ public final void rule__OpOther__Group_5_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6405:1: ( rule__OpOther__Group_5_1_0__0__Impl )
+ // InternalOXtype.g:6406:2: rule__OpOther__Group_5_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_5_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_5_1_0__0"
+
+
+ // $ANTLR start "rule__OpOther__Group_5_1_0__0__Impl"
+ // InternalOXtype.g:6412:1: rule__OpOther__Group_5_1_0__0__Impl : ( ( rule__OpOther__Group_5_1_0_0__0 ) ) ;
+ public final void rule__OpOther__Group_5_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6416:1: ( ( ( rule__OpOther__Group_5_1_0_0__0 ) ) )
+ // InternalOXtype.g:6417:1: ( ( rule__OpOther__Group_5_1_0_0__0 ) )
+ {
+ // InternalOXtype.g:6417:1: ( ( rule__OpOther__Group_5_1_0_0__0 ) )
+ // InternalOXtype.g:6418:2: ( rule__OpOther__Group_5_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0());
+ }
+ // InternalOXtype.g:6419:2: ( rule__OpOther__Group_5_1_0_0__0 )
+ // InternalOXtype.g:6419:3: rule__OpOther__Group_5_1_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_5_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_5_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__OpOther__Group_5_1_0_0__0"
+ // InternalOXtype.g:6428:1: rule__OpOther__Group_5_1_0_0__0 : rule__OpOther__Group_5_1_0_0__0__Impl rule__OpOther__Group_5_1_0_0__1 ;
+ public final void rule__OpOther__Group_5_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6432:1: ( rule__OpOther__Group_5_1_0_0__0__Impl rule__OpOther__Group_5_1_0_0__1 )
+ // InternalOXtype.g:6433:2: rule__OpOther__Group_5_1_0_0__0__Impl rule__OpOther__Group_5_1_0_0__1
+ {
+ pushFollow(FOLLOW_37);
+ rule__OpOther__Group_5_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_5_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_5_1_0_0__0"
+
+
+ // $ANTLR start "rule__OpOther__Group_5_1_0_0__0__Impl"
+ // InternalOXtype.g:6440:1: rule__OpOther__Group_5_1_0_0__0__Impl : ( '>' ) ;
+ public final void rule__OpOther__Group_5_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6444:1: ( ( '>' ) )
+ // InternalOXtype.g:6445:1: ( '>' )
+ {
+ // InternalOXtype.g:6445:1: ( '>' )
+ // InternalOXtype.g:6446:2: '>'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0());
+ }
+ match(input,26,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_5_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__OpOther__Group_5_1_0_0__1"
+ // InternalOXtype.g:6455:1: rule__OpOther__Group_5_1_0_0__1 : rule__OpOther__Group_5_1_0_0__1__Impl ;
+ public final void rule__OpOther__Group_5_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6459:1: ( rule__OpOther__Group_5_1_0_0__1__Impl )
+ // InternalOXtype.g:6460:2: rule__OpOther__Group_5_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_5_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_5_1_0_0__1"
+
+
+ // $ANTLR start "rule__OpOther__Group_5_1_0_0__1__Impl"
+ // InternalOXtype.g:6466:1: rule__OpOther__Group_5_1_0_0__1__Impl : ( '>' ) ;
+ public final void rule__OpOther__Group_5_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6470:1: ( ( '>' ) )
+ // InternalOXtype.g:6471:1: ( '>' )
+ {
+ // InternalOXtype.g:6471:1: ( '>' )
+ // InternalOXtype.g:6472:2: '>'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1());
+ }
+ match(input,26,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_5_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__OpOther__Group_6__0"
+ // InternalOXtype.g:6482:1: rule__OpOther__Group_6__0 : rule__OpOther__Group_6__0__Impl rule__OpOther__Group_6__1 ;
+ public final void rule__OpOther__Group_6__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6486:1: ( rule__OpOther__Group_6__0__Impl rule__OpOther__Group_6__1 )
+ // InternalOXtype.g:6487:2: rule__OpOther__Group_6__0__Impl rule__OpOther__Group_6__1
+ {
+ pushFollow(FOLLOW_38);
+ rule__OpOther__Group_6__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_6__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_6__0"
+
+
+ // $ANTLR start "rule__OpOther__Group_6__0__Impl"
+ // InternalOXtype.g:6494:1: rule__OpOther__Group_6__0__Impl : ( '<' ) ;
+ public final void rule__OpOther__Group_6__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6498:1: ( ( '<' ) )
+ // InternalOXtype.g:6499:1: ( '<' )
+ {
+ // InternalOXtype.g:6499:1: ( '<' )
+ // InternalOXtype.g:6500:2: '<'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0());
+ }
+ match(input,27,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_6__0__Impl"
+
+
+ // $ANTLR start "rule__OpOther__Group_6__1"
+ // InternalOXtype.g:6509:1: rule__OpOther__Group_6__1 : rule__OpOther__Group_6__1__Impl ;
+ public final void rule__OpOther__Group_6__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6513:1: ( rule__OpOther__Group_6__1__Impl )
+ // InternalOXtype.g:6514:2: rule__OpOther__Group_6__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_6__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_6__1"
+
+
+ // $ANTLR start "rule__OpOther__Group_6__1__Impl"
+ // InternalOXtype.g:6520:1: rule__OpOther__Group_6__1__Impl : ( ( rule__OpOther__Alternatives_6_1 ) ) ;
+ public final void rule__OpOther__Group_6__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6524:1: ( ( ( rule__OpOther__Alternatives_6_1 ) ) )
+ // InternalOXtype.g:6525:1: ( ( rule__OpOther__Alternatives_6_1 ) )
+ {
+ // InternalOXtype.g:6525:1: ( ( rule__OpOther__Alternatives_6_1 ) )
+ // InternalOXtype.g:6526:2: ( rule__OpOther__Alternatives_6_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getAlternatives_6_1());
+ }
+ // InternalOXtype.g:6527:2: ( rule__OpOther__Alternatives_6_1 )
+ // InternalOXtype.g:6527:3: rule__OpOther__Alternatives_6_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Alternatives_6_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getAlternatives_6_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_6__1__Impl"
+
+
+ // $ANTLR start "rule__OpOther__Group_6_1_0__0"
+ // InternalOXtype.g:6536:1: rule__OpOther__Group_6_1_0__0 : rule__OpOther__Group_6_1_0__0__Impl ;
+ public final void rule__OpOther__Group_6_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6540:1: ( rule__OpOther__Group_6_1_0__0__Impl )
+ // InternalOXtype.g:6541:2: rule__OpOther__Group_6_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_6_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_6_1_0__0"
+
+
+ // $ANTLR start "rule__OpOther__Group_6_1_0__0__Impl"
+ // InternalOXtype.g:6547:1: rule__OpOther__Group_6_1_0__0__Impl : ( ( rule__OpOther__Group_6_1_0_0__0 ) ) ;
+ public final void rule__OpOther__Group_6_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6551:1: ( ( ( rule__OpOther__Group_6_1_0_0__0 ) ) )
+ // InternalOXtype.g:6552:1: ( ( rule__OpOther__Group_6_1_0_0__0 ) )
+ {
+ // InternalOXtype.g:6552:1: ( ( rule__OpOther__Group_6_1_0_0__0 ) )
+ // InternalOXtype.g:6553:2: ( rule__OpOther__Group_6_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0());
+ }
+ // InternalOXtype.g:6554:2: ( rule__OpOther__Group_6_1_0_0__0 )
+ // InternalOXtype.g:6554:3: rule__OpOther__Group_6_1_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_6_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_6_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__OpOther__Group_6_1_0_0__0"
+ // InternalOXtype.g:6563:1: rule__OpOther__Group_6_1_0_0__0 : rule__OpOther__Group_6_1_0_0__0__Impl rule__OpOther__Group_6_1_0_0__1 ;
+ public final void rule__OpOther__Group_6_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6567:1: ( rule__OpOther__Group_6_1_0_0__0__Impl rule__OpOther__Group_6_1_0_0__1 )
+ // InternalOXtype.g:6568:2: rule__OpOther__Group_6_1_0_0__0__Impl rule__OpOther__Group_6_1_0_0__1
+ {
+ pushFollow(FOLLOW_22);
+ rule__OpOther__Group_6_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_6_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_6_1_0_0__0"
+
+
+ // $ANTLR start "rule__OpOther__Group_6_1_0_0__0__Impl"
+ // InternalOXtype.g:6575:1: rule__OpOther__Group_6_1_0_0__0__Impl : ( '<' ) ;
+ public final void rule__OpOther__Group_6_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6579:1: ( ( '<' ) )
+ // InternalOXtype.g:6580:1: ( '<' )
+ {
+ // InternalOXtype.g:6580:1: ( '<' )
+ // InternalOXtype.g:6581:2: '<'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0());
+ }
+ match(input,27,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_6_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__OpOther__Group_6_1_0_0__1"
+ // InternalOXtype.g:6590:1: rule__OpOther__Group_6_1_0_0__1 : rule__OpOther__Group_6_1_0_0__1__Impl ;
+ public final void rule__OpOther__Group_6_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6594:1: ( rule__OpOther__Group_6_1_0_0__1__Impl )
+ // InternalOXtype.g:6595:2: rule__OpOther__Group_6_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_6_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_6_1_0_0__1"
+
+
+ // $ANTLR start "rule__OpOther__Group_6_1_0_0__1__Impl"
+ // InternalOXtype.g:6601:1: rule__OpOther__Group_6_1_0_0__1__Impl : ( '<' ) ;
+ public final void rule__OpOther__Group_6_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6605:1: ( ( '<' ) )
+ // InternalOXtype.g:6606:1: ( '<' )
+ {
+ // InternalOXtype.g:6606:1: ( '<' )
+ // InternalOXtype.g:6607:2: '<'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1());
+ }
+ match(input,27,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__OpOther__Group_6_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XAdditiveExpression__Group__0"
+ // InternalOXtype.g:6617:1: rule__XAdditiveExpression__Group__0 : rule__XAdditiveExpression__Group__0__Impl rule__XAdditiveExpression__Group__1 ;
+ public final void rule__XAdditiveExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6621:1: ( rule__XAdditiveExpression__Group__0__Impl rule__XAdditiveExpression__Group__1 )
+ // InternalOXtype.g:6622:2: rule__XAdditiveExpression__Group__0__Impl rule__XAdditiveExpression__Group__1
+ {
+ pushFollow(FOLLOW_39);
+ rule__XAdditiveExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAdditiveExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAdditiveExpression__Group__0"
+
+
+ // $ANTLR start "rule__XAdditiveExpression__Group__0__Impl"
+ // InternalOXtype.g:6629:1: rule__XAdditiveExpression__Group__0__Impl : ( ruleXMultiplicativeExpression ) ;
+ public final void rule__XAdditiveExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6633:1: ( ( ruleXMultiplicativeExpression ) )
+ // InternalOXtype.g:6634:1: ( ruleXMultiplicativeExpression )
+ {
+ // InternalOXtype.g:6634:1: ( ruleXMultiplicativeExpression )
+ // InternalOXtype.g:6635:2: ruleXMultiplicativeExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXMultiplicativeExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAdditiveExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XAdditiveExpression__Group__1"
+ // InternalOXtype.g:6644:1: rule__XAdditiveExpression__Group__1 : rule__XAdditiveExpression__Group__1__Impl ;
+ public final void rule__XAdditiveExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6648:1: ( rule__XAdditiveExpression__Group__1__Impl )
+ // InternalOXtype.g:6649:2: rule__XAdditiveExpression__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAdditiveExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAdditiveExpression__Group__1"
+
+
+ // $ANTLR start "rule__XAdditiveExpression__Group__1__Impl"
+ // InternalOXtype.g:6655:1: rule__XAdditiveExpression__Group__1__Impl : ( ( rule__XAdditiveExpression__Group_1__0 )* ) ;
+ public final void rule__XAdditiveExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6659:1: ( ( ( rule__XAdditiveExpression__Group_1__0 )* ) )
+ // InternalOXtype.g:6660:1: ( ( rule__XAdditiveExpression__Group_1__0 )* )
+ {
+ // InternalOXtype.g:6660:1: ( ( rule__XAdditiveExpression__Group_1__0 )* )
+ // InternalOXtype.g:6661:2: ( rule__XAdditiveExpression__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1());
+ }
+ // InternalOXtype.g:6662:2: ( rule__XAdditiveExpression__Group_1__0 )*
+ loop63:
+ do {
+ int alt63=2;
+ int LA63_0 = input.LA(1);
+
+ if ( (LA63_0==35) ) {
+ int LA63_2 = input.LA(2);
+
+ if ( (synpred107_InternalOXtype()) ) {
+ alt63=1;
+ }
+
+
+ }
+ else if ( (LA63_0==34) ) {
+ int LA63_3 = input.LA(2);
+
+ if ( (synpred107_InternalOXtype()) ) {
+ alt63=1;
+ }
+
+
+ }
+
+
+ switch (alt63) {
+ case 1 :
+ // InternalOXtype.g:6662:3: rule__XAdditiveExpression__Group_1__0
+ {
+ pushFollow(FOLLOW_40);
+ rule__XAdditiveExpression__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop63;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAdditiveExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XAdditiveExpression__Group_1__0"
+ // InternalOXtype.g:6671:1: rule__XAdditiveExpression__Group_1__0 : rule__XAdditiveExpression__Group_1__0__Impl rule__XAdditiveExpression__Group_1__1 ;
+ public final void rule__XAdditiveExpression__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6675:1: ( rule__XAdditiveExpression__Group_1__0__Impl rule__XAdditiveExpression__Group_1__1 )
+ // InternalOXtype.g:6676:2: rule__XAdditiveExpression__Group_1__0__Impl rule__XAdditiveExpression__Group_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XAdditiveExpression__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAdditiveExpression__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAdditiveExpression__Group_1__0"
+
+
+ // $ANTLR start "rule__XAdditiveExpression__Group_1__0__Impl"
+ // InternalOXtype.g:6683:1: rule__XAdditiveExpression__Group_1__0__Impl : ( ( rule__XAdditiveExpression__Group_1_0__0 ) ) ;
+ public final void rule__XAdditiveExpression__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6687:1: ( ( ( rule__XAdditiveExpression__Group_1_0__0 ) ) )
+ // InternalOXtype.g:6688:1: ( ( rule__XAdditiveExpression__Group_1_0__0 ) )
+ {
+ // InternalOXtype.g:6688:1: ( ( rule__XAdditiveExpression__Group_1_0__0 ) )
+ // InternalOXtype.g:6689:2: ( rule__XAdditiveExpression__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0());
+ }
+ // InternalOXtype.g:6690:2: ( rule__XAdditiveExpression__Group_1_0__0 )
+ // InternalOXtype.g:6690:3: rule__XAdditiveExpression__Group_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAdditiveExpression__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAdditiveExpression__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__XAdditiveExpression__Group_1__1"
+ // InternalOXtype.g:6698:1: rule__XAdditiveExpression__Group_1__1 : rule__XAdditiveExpression__Group_1__1__Impl ;
+ public final void rule__XAdditiveExpression__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6702:1: ( rule__XAdditiveExpression__Group_1__1__Impl )
+ // InternalOXtype.g:6703:2: rule__XAdditiveExpression__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAdditiveExpression__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAdditiveExpression__Group_1__1"
+
+
+ // $ANTLR start "rule__XAdditiveExpression__Group_1__1__Impl"
+ // InternalOXtype.g:6709:1: rule__XAdditiveExpression__Group_1__1__Impl : ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) ) ;
+ public final void rule__XAdditiveExpression__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6713:1: ( ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) ) )
+ // InternalOXtype.g:6714:1: ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) )
+ {
+ // InternalOXtype.g:6714:1: ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) )
+ // InternalOXtype.g:6715:2: ( rule__XAdditiveExpression__RightOperandAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1());
+ }
+ // InternalOXtype.g:6716:2: ( rule__XAdditiveExpression__RightOperandAssignment_1_1 )
+ // InternalOXtype.g:6716:3: rule__XAdditiveExpression__RightOperandAssignment_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAdditiveExpression__RightOperandAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAdditiveExpression__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__XAdditiveExpression__Group_1_0__0"
+ // InternalOXtype.g:6725:1: rule__XAdditiveExpression__Group_1_0__0 : rule__XAdditiveExpression__Group_1_0__0__Impl ;
+ public final void rule__XAdditiveExpression__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6729:1: ( rule__XAdditiveExpression__Group_1_0__0__Impl )
+ // InternalOXtype.g:6730:2: rule__XAdditiveExpression__Group_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAdditiveExpression__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAdditiveExpression__Group_1_0__0"
+
+
+ // $ANTLR start "rule__XAdditiveExpression__Group_1_0__0__Impl"
+ // InternalOXtype.g:6736:1: rule__XAdditiveExpression__Group_1_0__0__Impl : ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) ) ;
+ public final void rule__XAdditiveExpression__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6740:1: ( ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) ) )
+ // InternalOXtype.g:6741:1: ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) )
+ {
+ // InternalOXtype.g:6741:1: ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) )
+ // InternalOXtype.g:6742:2: ( rule__XAdditiveExpression__Group_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0());
+ }
+ // InternalOXtype.g:6743:2: ( rule__XAdditiveExpression__Group_1_0_0__0 )
+ // InternalOXtype.g:6743:3: rule__XAdditiveExpression__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAdditiveExpression__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAdditiveExpression__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__0"
+ // InternalOXtype.g:6752:1: rule__XAdditiveExpression__Group_1_0_0__0 : rule__XAdditiveExpression__Group_1_0_0__0__Impl rule__XAdditiveExpression__Group_1_0_0__1 ;
+ public final void rule__XAdditiveExpression__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6756:1: ( rule__XAdditiveExpression__Group_1_0_0__0__Impl rule__XAdditiveExpression__Group_1_0_0__1 )
+ // InternalOXtype.g:6757:2: rule__XAdditiveExpression__Group_1_0_0__0__Impl rule__XAdditiveExpression__Group_1_0_0__1
+ {
+ pushFollow(FOLLOW_39);
+ rule__XAdditiveExpression__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XAdditiveExpression__Group_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__0__Impl"
+ // InternalOXtype.g:6764:1: rule__XAdditiveExpression__Group_1_0_0__0__Impl : ( () ) ;
+ public final void rule__XAdditiveExpression__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6768:1: ( ( () ) )
+ // InternalOXtype.g:6769:1: ( () )
+ {
+ // InternalOXtype.g:6769:1: ( () )
+ // InternalOXtype.g:6770:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0());
+ }
+ // InternalOXtype.g:6771:2: ()
+ // InternalOXtype.g:6771:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__1"
+ // InternalOXtype.g:6779:1: rule__XAdditiveExpression__Group_1_0_0__1 : rule__XAdditiveExpression__Group_1_0_0__1__Impl ;
+ public final void rule__XAdditiveExpression__Group_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6783:1: ( rule__XAdditiveExpression__Group_1_0_0__1__Impl )
+ // InternalOXtype.g:6784:2: rule__XAdditiveExpression__Group_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAdditiveExpression__Group_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__1"
+
+
+ // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__1__Impl"
+ // InternalOXtype.g:6790:1: rule__XAdditiveExpression__Group_1_0_0__1__Impl : ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) ) ;
+ public final void rule__XAdditiveExpression__Group_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6794:1: ( ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) ) )
+ // InternalOXtype.g:6795:1: ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) )
+ {
+ // InternalOXtype.g:6795:1: ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) )
+ // InternalOXtype.g:6796:2: ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1());
+ }
+ // InternalOXtype.g:6797:2: ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 )
+ // InternalOXtype.g:6797:3: rule__XAdditiveExpression__FeatureAssignment_1_0_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAdditiveExpression__FeatureAssignment_1_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XMultiplicativeExpression__Group__0"
+ // InternalOXtype.g:6806:1: rule__XMultiplicativeExpression__Group__0 : rule__XMultiplicativeExpression__Group__0__Impl rule__XMultiplicativeExpression__Group__1 ;
+ public final void rule__XMultiplicativeExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6810:1: ( rule__XMultiplicativeExpression__Group__0__Impl rule__XMultiplicativeExpression__Group__1 )
+ // InternalOXtype.g:6811:2: rule__XMultiplicativeExpression__Group__0__Impl rule__XMultiplicativeExpression__Group__1
+ {
+ pushFollow(FOLLOW_41);
+ rule__XMultiplicativeExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMultiplicativeExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMultiplicativeExpression__Group__0"
+
+
+ // $ANTLR start "rule__XMultiplicativeExpression__Group__0__Impl"
+ // InternalOXtype.g:6818:1: rule__XMultiplicativeExpression__Group__0__Impl : ( ruleXUnaryOperation ) ;
+ public final void rule__XMultiplicativeExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6822:1: ( ( ruleXUnaryOperation ) )
+ // InternalOXtype.g:6823:1: ( ruleXUnaryOperation )
+ {
+ // InternalOXtype.g:6823:1: ( ruleXUnaryOperation )
+ // InternalOXtype.g:6824:2: ruleXUnaryOperation
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXUnaryOperation();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMultiplicativeExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XMultiplicativeExpression__Group__1"
+ // InternalOXtype.g:6833:1: rule__XMultiplicativeExpression__Group__1 : rule__XMultiplicativeExpression__Group__1__Impl ;
+ public final void rule__XMultiplicativeExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6837:1: ( rule__XMultiplicativeExpression__Group__1__Impl )
+ // InternalOXtype.g:6838:2: rule__XMultiplicativeExpression__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMultiplicativeExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMultiplicativeExpression__Group__1"
+
+
+ // $ANTLR start "rule__XMultiplicativeExpression__Group__1__Impl"
+ // InternalOXtype.g:6844:1: rule__XMultiplicativeExpression__Group__1__Impl : ( ( rule__XMultiplicativeExpression__Group_1__0 )* ) ;
+ public final void rule__XMultiplicativeExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6848:1: ( ( ( rule__XMultiplicativeExpression__Group_1__0 )* ) )
+ // InternalOXtype.g:6849:1: ( ( rule__XMultiplicativeExpression__Group_1__0 )* )
+ {
+ // InternalOXtype.g:6849:1: ( ( rule__XMultiplicativeExpression__Group_1__0 )* )
+ // InternalOXtype.g:6850:2: ( rule__XMultiplicativeExpression__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1());
+ }
+ // InternalOXtype.g:6851:2: ( rule__XMultiplicativeExpression__Group_1__0 )*
+ loop64:
+ do {
+ int alt64=2;
+ switch ( input.LA(1) ) {
+ case 36:
+ {
+ int LA64_2 = input.LA(2);
+
+ if ( (synpred108_InternalOXtype()) ) {
+ alt64=1;
+ }
+
+
+ }
+ break;
+ case 37:
+ {
+ int LA64_3 = input.LA(2);
+
+ if ( (synpred108_InternalOXtype()) ) {
+ alt64=1;
+ }
+
+
+ }
+ break;
+ case 38:
+ {
+ int LA64_4 = input.LA(2);
+
+ if ( (synpred108_InternalOXtype()) ) {
+ alt64=1;
+ }
+
+
+ }
+ break;
+ case 39:
+ {
+ int LA64_5 = input.LA(2);
+
+ if ( (synpred108_InternalOXtype()) ) {
+ alt64=1;
+ }
+
+
+ }
+ break;
+
+ }
+
+ switch (alt64) {
+ case 1 :
+ // InternalOXtype.g:6851:3: rule__XMultiplicativeExpression__Group_1__0
+ {
+ pushFollow(FOLLOW_42);
+ rule__XMultiplicativeExpression__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop64;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMultiplicativeExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XMultiplicativeExpression__Group_1__0"
+ // InternalOXtype.g:6860:1: rule__XMultiplicativeExpression__Group_1__0 : rule__XMultiplicativeExpression__Group_1__0__Impl rule__XMultiplicativeExpression__Group_1__1 ;
+ public final void rule__XMultiplicativeExpression__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6864:1: ( rule__XMultiplicativeExpression__Group_1__0__Impl rule__XMultiplicativeExpression__Group_1__1 )
+ // InternalOXtype.g:6865:2: rule__XMultiplicativeExpression__Group_1__0__Impl rule__XMultiplicativeExpression__Group_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XMultiplicativeExpression__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMultiplicativeExpression__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMultiplicativeExpression__Group_1__0"
+
+
+ // $ANTLR start "rule__XMultiplicativeExpression__Group_1__0__Impl"
+ // InternalOXtype.g:6872:1: rule__XMultiplicativeExpression__Group_1__0__Impl : ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) ) ;
+ public final void rule__XMultiplicativeExpression__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6876:1: ( ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) ) )
+ // InternalOXtype.g:6877:1: ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) )
+ {
+ // InternalOXtype.g:6877:1: ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) )
+ // InternalOXtype.g:6878:2: ( rule__XMultiplicativeExpression__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0());
+ }
+ // InternalOXtype.g:6879:2: ( rule__XMultiplicativeExpression__Group_1_0__0 )
+ // InternalOXtype.g:6879:3: rule__XMultiplicativeExpression__Group_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMultiplicativeExpression__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMultiplicativeExpression__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__XMultiplicativeExpression__Group_1__1"
+ // InternalOXtype.g:6887:1: rule__XMultiplicativeExpression__Group_1__1 : rule__XMultiplicativeExpression__Group_1__1__Impl ;
+ public final void rule__XMultiplicativeExpression__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6891:1: ( rule__XMultiplicativeExpression__Group_1__1__Impl )
+ // InternalOXtype.g:6892:2: rule__XMultiplicativeExpression__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMultiplicativeExpression__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMultiplicativeExpression__Group_1__1"
+
+
+ // $ANTLR start "rule__XMultiplicativeExpression__Group_1__1__Impl"
+ // InternalOXtype.g:6898:1: rule__XMultiplicativeExpression__Group_1__1__Impl : ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) ) ;
+ public final void rule__XMultiplicativeExpression__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6902:1: ( ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) ) )
+ // InternalOXtype.g:6903:1: ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) )
+ {
+ // InternalOXtype.g:6903:1: ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) )
+ // InternalOXtype.g:6904:2: ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1());
+ }
+ // InternalOXtype.g:6905:2: ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 )
+ // InternalOXtype.g:6905:3: rule__XMultiplicativeExpression__RightOperandAssignment_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMultiplicativeExpression__RightOperandAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMultiplicativeExpression__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0__0"
+ // InternalOXtype.g:6914:1: rule__XMultiplicativeExpression__Group_1_0__0 : rule__XMultiplicativeExpression__Group_1_0__0__Impl ;
+ public final void rule__XMultiplicativeExpression__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6918:1: ( rule__XMultiplicativeExpression__Group_1_0__0__Impl )
+ // InternalOXtype.g:6919:2: rule__XMultiplicativeExpression__Group_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMultiplicativeExpression__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0__0"
+
+
+ // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0__0__Impl"
+ // InternalOXtype.g:6925:1: rule__XMultiplicativeExpression__Group_1_0__0__Impl : ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) ) ;
+ public final void rule__XMultiplicativeExpression__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6929:1: ( ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) ) )
+ // InternalOXtype.g:6930:1: ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) )
+ {
+ // InternalOXtype.g:6930:1: ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) )
+ // InternalOXtype.g:6931:2: ( rule__XMultiplicativeExpression__Group_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0());
+ }
+ // InternalOXtype.g:6932:2: ( rule__XMultiplicativeExpression__Group_1_0_0__0 )
+ // InternalOXtype.g:6932:3: rule__XMultiplicativeExpression__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMultiplicativeExpression__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__0"
+ // InternalOXtype.g:6941:1: rule__XMultiplicativeExpression__Group_1_0_0__0 : rule__XMultiplicativeExpression__Group_1_0_0__0__Impl rule__XMultiplicativeExpression__Group_1_0_0__1 ;
+ public final void rule__XMultiplicativeExpression__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6945:1: ( rule__XMultiplicativeExpression__Group_1_0_0__0__Impl rule__XMultiplicativeExpression__Group_1_0_0__1 )
+ // InternalOXtype.g:6946:2: rule__XMultiplicativeExpression__Group_1_0_0__0__Impl rule__XMultiplicativeExpression__Group_1_0_0__1
+ {
+ pushFollow(FOLLOW_41);
+ rule__XMultiplicativeExpression__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMultiplicativeExpression__Group_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__0__Impl"
+ // InternalOXtype.g:6953:1: rule__XMultiplicativeExpression__Group_1_0_0__0__Impl : ( () ) ;
+ public final void rule__XMultiplicativeExpression__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6957:1: ( ( () ) )
+ // InternalOXtype.g:6958:1: ( () )
+ {
+ // InternalOXtype.g:6958:1: ( () )
+ // InternalOXtype.g:6959:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0());
+ }
+ // InternalOXtype.g:6960:2: ()
+ // InternalOXtype.g:6960:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__1"
+ // InternalOXtype.g:6968:1: rule__XMultiplicativeExpression__Group_1_0_0__1 : rule__XMultiplicativeExpression__Group_1_0_0__1__Impl ;
+ public final void rule__XMultiplicativeExpression__Group_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6972:1: ( rule__XMultiplicativeExpression__Group_1_0_0__1__Impl )
+ // InternalOXtype.g:6973:2: rule__XMultiplicativeExpression__Group_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMultiplicativeExpression__Group_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__1"
+
+
+ // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__1__Impl"
+ // InternalOXtype.g:6979:1: rule__XMultiplicativeExpression__Group_1_0_0__1__Impl : ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) ) ;
+ public final void rule__XMultiplicativeExpression__Group_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6983:1: ( ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) ) )
+ // InternalOXtype.g:6984:1: ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) )
+ {
+ // InternalOXtype.g:6984:1: ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) )
+ // InternalOXtype.g:6985:2: ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1());
+ }
+ // InternalOXtype.g:6986:2: ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 )
+ // InternalOXtype.g:6986:3: rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XUnaryOperation__Group_0__0"
+ // InternalOXtype.g:6995:1: rule__XUnaryOperation__Group_0__0 : rule__XUnaryOperation__Group_0__0__Impl rule__XUnaryOperation__Group_0__1 ;
+ public final void rule__XUnaryOperation__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:6999:1: ( rule__XUnaryOperation__Group_0__0__Impl rule__XUnaryOperation__Group_0__1 )
+ // InternalOXtype.g:7000:2: rule__XUnaryOperation__Group_0__0__Impl rule__XUnaryOperation__Group_0__1
+ {
+ pushFollow(FOLLOW_43);
+ rule__XUnaryOperation__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XUnaryOperation__Group_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XUnaryOperation__Group_0__0"
+
+
+ // $ANTLR start "rule__XUnaryOperation__Group_0__0__Impl"
+ // InternalOXtype.g:7007:1: rule__XUnaryOperation__Group_0__0__Impl : ( () ) ;
+ public final void rule__XUnaryOperation__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7011:1: ( ( () ) )
+ // InternalOXtype.g:7012:1: ( () )
+ {
+ // InternalOXtype.g:7012:1: ( () )
+ // InternalOXtype.g:7013:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0());
+ }
+ // InternalOXtype.g:7014:2: ()
+ // InternalOXtype.g:7014:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XUnaryOperation__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__XUnaryOperation__Group_0__1"
+ // InternalOXtype.g:7022:1: rule__XUnaryOperation__Group_0__1 : rule__XUnaryOperation__Group_0__1__Impl rule__XUnaryOperation__Group_0__2 ;
+ public final void rule__XUnaryOperation__Group_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7026:1: ( rule__XUnaryOperation__Group_0__1__Impl rule__XUnaryOperation__Group_0__2 )
+ // InternalOXtype.g:7027:2: rule__XUnaryOperation__Group_0__1__Impl rule__XUnaryOperation__Group_0__2
+ {
+ pushFollow(FOLLOW_15);
+ rule__XUnaryOperation__Group_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XUnaryOperation__Group_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XUnaryOperation__Group_0__1"
+
+
+ // $ANTLR start "rule__XUnaryOperation__Group_0__1__Impl"
+ // InternalOXtype.g:7034:1: rule__XUnaryOperation__Group_0__1__Impl : ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) ) ;
+ public final void rule__XUnaryOperation__Group_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7038:1: ( ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) ) )
+ // InternalOXtype.g:7039:1: ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) )
+ {
+ // InternalOXtype.g:7039:1: ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) )
+ // InternalOXtype.g:7040:2: ( rule__XUnaryOperation__FeatureAssignment_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1());
+ }
+ // InternalOXtype.g:7041:2: ( rule__XUnaryOperation__FeatureAssignment_0_1 )
+ // InternalOXtype.g:7041:3: rule__XUnaryOperation__FeatureAssignment_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XUnaryOperation__FeatureAssignment_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XUnaryOperation__Group_0__1__Impl"
+
+
+ // $ANTLR start "rule__XUnaryOperation__Group_0__2"
+ // InternalOXtype.g:7049:1: rule__XUnaryOperation__Group_0__2 : rule__XUnaryOperation__Group_0__2__Impl ;
+ public final void rule__XUnaryOperation__Group_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7053:1: ( rule__XUnaryOperation__Group_0__2__Impl )
+ // InternalOXtype.g:7054:2: rule__XUnaryOperation__Group_0__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XUnaryOperation__Group_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XUnaryOperation__Group_0__2"
+
+
+ // $ANTLR start "rule__XUnaryOperation__Group_0__2__Impl"
+ // InternalOXtype.g:7060:1: rule__XUnaryOperation__Group_0__2__Impl : ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) ) ;
+ public final void rule__XUnaryOperation__Group_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7064:1: ( ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) ) )
+ // InternalOXtype.g:7065:1: ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) )
+ {
+ // InternalOXtype.g:7065:1: ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) )
+ // InternalOXtype.g:7066:2: ( rule__XUnaryOperation__OperandAssignment_0_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2());
+ }
+ // InternalOXtype.g:7067:2: ( rule__XUnaryOperation__OperandAssignment_0_2 )
+ // InternalOXtype.g:7067:3: rule__XUnaryOperation__OperandAssignment_0_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XUnaryOperation__OperandAssignment_0_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XUnaryOperation__Group_0__2__Impl"
+
+
+ // $ANTLR start "rule__XCastedExpression__Group__0"
+ // InternalOXtype.g:7076:1: rule__XCastedExpression__Group__0 : rule__XCastedExpression__Group__0__Impl rule__XCastedExpression__Group__1 ;
+ public final void rule__XCastedExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7080:1: ( rule__XCastedExpression__Group__0__Impl rule__XCastedExpression__Group__1 )
+ // InternalOXtype.g:7081:2: rule__XCastedExpression__Group__0__Impl rule__XCastedExpression__Group__1
+ {
+ pushFollow(FOLLOW_44);
+ rule__XCastedExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XCastedExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCastedExpression__Group__0"
+
+
+ // $ANTLR start "rule__XCastedExpression__Group__0__Impl"
+ // InternalOXtype.g:7088:1: rule__XCastedExpression__Group__0__Impl : ( ruleXPostfixOperation ) ;
+ public final void rule__XCastedExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7092:1: ( ( ruleXPostfixOperation ) )
+ // InternalOXtype.g:7093:1: ( ruleXPostfixOperation )
+ {
+ // InternalOXtype.g:7093:1: ( ruleXPostfixOperation )
+ // InternalOXtype.g:7094:2: ruleXPostfixOperation
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXPostfixOperation();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCastedExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XCastedExpression__Group__1"
+ // InternalOXtype.g:7103:1: rule__XCastedExpression__Group__1 : rule__XCastedExpression__Group__1__Impl ;
+ public final void rule__XCastedExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7107:1: ( rule__XCastedExpression__Group__1__Impl )
+ // InternalOXtype.g:7108:2: rule__XCastedExpression__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCastedExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCastedExpression__Group__1"
+
+
+ // $ANTLR start "rule__XCastedExpression__Group__1__Impl"
+ // InternalOXtype.g:7114:1: rule__XCastedExpression__Group__1__Impl : ( ( rule__XCastedExpression__Group_1__0 )* ) ;
+ public final void rule__XCastedExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7118:1: ( ( ( rule__XCastedExpression__Group_1__0 )* ) )
+ // InternalOXtype.g:7119:1: ( ( rule__XCastedExpression__Group_1__0 )* )
+ {
+ // InternalOXtype.g:7119:1: ( ( rule__XCastedExpression__Group_1__0 )* )
+ // InternalOXtype.g:7120:2: ( rule__XCastedExpression__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCastedExpressionAccess().getGroup_1());
+ }
+ // InternalOXtype.g:7121:2: ( rule__XCastedExpression__Group_1__0 )*
+ loop65:
+ do {
+ int alt65=2;
+ int LA65_0 = input.LA(1);
+
+ if ( (LA65_0==60) ) {
+ int LA65_2 = input.LA(2);
+
+ if ( (synpred109_InternalOXtype()) ) {
+ alt65=1;
+ }
+
+
+ }
+
+
+ switch (alt65) {
+ case 1 :
+ // InternalOXtype.g:7121:3: rule__XCastedExpression__Group_1__0
+ {
+ pushFollow(FOLLOW_45);
+ rule__XCastedExpression__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop65;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCastedExpressionAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCastedExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XCastedExpression__Group_1__0"
+ // InternalOXtype.g:7130:1: rule__XCastedExpression__Group_1__0 : rule__XCastedExpression__Group_1__0__Impl rule__XCastedExpression__Group_1__1 ;
+ public final void rule__XCastedExpression__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7134:1: ( rule__XCastedExpression__Group_1__0__Impl rule__XCastedExpression__Group_1__1 )
+ // InternalOXtype.g:7135:2: rule__XCastedExpression__Group_1__0__Impl rule__XCastedExpression__Group_1__1
+ {
+ pushFollow(FOLLOW_32);
+ rule__XCastedExpression__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XCastedExpression__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCastedExpression__Group_1__0"
+
+
+ // $ANTLR start "rule__XCastedExpression__Group_1__0__Impl"
+ // InternalOXtype.g:7142:1: rule__XCastedExpression__Group_1__0__Impl : ( ( rule__XCastedExpression__Group_1_0__0 ) ) ;
+ public final void rule__XCastedExpression__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7146:1: ( ( ( rule__XCastedExpression__Group_1_0__0 ) ) )
+ // InternalOXtype.g:7147:1: ( ( rule__XCastedExpression__Group_1_0__0 ) )
+ {
+ // InternalOXtype.g:7147:1: ( ( rule__XCastedExpression__Group_1_0__0 ) )
+ // InternalOXtype.g:7148:2: ( rule__XCastedExpression__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0());
+ }
+ // InternalOXtype.g:7149:2: ( rule__XCastedExpression__Group_1_0__0 )
+ // InternalOXtype.g:7149:3: rule__XCastedExpression__Group_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCastedExpression__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCastedExpression__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__XCastedExpression__Group_1__1"
+ // InternalOXtype.g:7157:1: rule__XCastedExpression__Group_1__1 : rule__XCastedExpression__Group_1__1__Impl ;
+ public final void rule__XCastedExpression__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7161:1: ( rule__XCastedExpression__Group_1__1__Impl )
+ // InternalOXtype.g:7162:2: rule__XCastedExpression__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCastedExpression__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCastedExpression__Group_1__1"
+
+
+ // $ANTLR start "rule__XCastedExpression__Group_1__1__Impl"
+ // InternalOXtype.g:7168:1: rule__XCastedExpression__Group_1__1__Impl : ( ( rule__XCastedExpression__TypeAssignment_1_1 ) ) ;
+ public final void rule__XCastedExpression__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7172:1: ( ( ( rule__XCastedExpression__TypeAssignment_1_1 ) ) )
+ // InternalOXtype.g:7173:1: ( ( rule__XCastedExpression__TypeAssignment_1_1 ) )
+ {
+ // InternalOXtype.g:7173:1: ( ( rule__XCastedExpression__TypeAssignment_1_1 ) )
+ // InternalOXtype.g:7174:2: ( rule__XCastedExpression__TypeAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1());
+ }
+ // InternalOXtype.g:7175:2: ( rule__XCastedExpression__TypeAssignment_1_1 )
+ // InternalOXtype.g:7175:3: rule__XCastedExpression__TypeAssignment_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCastedExpression__TypeAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCastedExpression__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__XCastedExpression__Group_1_0__0"
+ // InternalOXtype.g:7184:1: rule__XCastedExpression__Group_1_0__0 : rule__XCastedExpression__Group_1_0__0__Impl ;
+ public final void rule__XCastedExpression__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7188:1: ( rule__XCastedExpression__Group_1_0__0__Impl )
+ // InternalOXtype.g:7189:2: rule__XCastedExpression__Group_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCastedExpression__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCastedExpression__Group_1_0__0"
+
+
+ // $ANTLR start "rule__XCastedExpression__Group_1_0__0__Impl"
+ // InternalOXtype.g:7195:1: rule__XCastedExpression__Group_1_0__0__Impl : ( ( rule__XCastedExpression__Group_1_0_0__0 ) ) ;
+ public final void rule__XCastedExpression__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7199:1: ( ( ( rule__XCastedExpression__Group_1_0_0__0 ) ) )
+ // InternalOXtype.g:7200:1: ( ( rule__XCastedExpression__Group_1_0_0__0 ) )
+ {
+ // InternalOXtype.g:7200:1: ( ( rule__XCastedExpression__Group_1_0_0__0 ) )
+ // InternalOXtype.g:7201:2: ( rule__XCastedExpression__Group_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0());
+ }
+ // InternalOXtype.g:7202:2: ( rule__XCastedExpression__Group_1_0_0__0 )
+ // InternalOXtype.g:7202:3: rule__XCastedExpression__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCastedExpression__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCastedExpression__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__XCastedExpression__Group_1_0_0__0"
+ // InternalOXtype.g:7211:1: rule__XCastedExpression__Group_1_0_0__0 : rule__XCastedExpression__Group_1_0_0__0__Impl rule__XCastedExpression__Group_1_0_0__1 ;
+ public final void rule__XCastedExpression__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7215:1: ( rule__XCastedExpression__Group_1_0_0__0__Impl rule__XCastedExpression__Group_1_0_0__1 )
+ // InternalOXtype.g:7216:2: rule__XCastedExpression__Group_1_0_0__0__Impl rule__XCastedExpression__Group_1_0_0__1
+ {
+ pushFollow(FOLLOW_44);
+ rule__XCastedExpression__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XCastedExpression__Group_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCastedExpression__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__XCastedExpression__Group_1_0_0__0__Impl"
+ // InternalOXtype.g:7223:1: rule__XCastedExpression__Group_1_0_0__0__Impl : ( () ) ;
+ public final void rule__XCastedExpression__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7227:1: ( ( () ) )
+ // InternalOXtype.g:7228:1: ( () )
+ {
+ // InternalOXtype.g:7228:1: ( () )
+ // InternalOXtype.g:7229:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0());
+ }
+ // InternalOXtype.g:7230:2: ()
+ // InternalOXtype.g:7230:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCastedExpression__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XCastedExpression__Group_1_0_0__1"
+ // InternalOXtype.g:7238:1: rule__XCastedExpression__Group_1_0_0__1 : rule__XCastedExpression__Group_1_0_0__1__Impl ;
+ public final void rule__XCastedExpression__Group_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7242:1: ( rule__XCastedExpression__Group_1_0_0__1__Impl )
+ // InternalOXtype.g:7243:2: rule__XCastedExpression__Group_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCastedExpression__Group_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCastedExpression__Group_1_0_0__1"
+
+
+ // $ANTLR start "rule__XCastedExpression__Group_1_0_0__1__Impl"
+ // InternalOXtype.g:7249:1: rule__XCastedExpression__Group_1_0_0__1__Impl : ( 'as' ) ;
+ public final void rule__XCastedExpression__Group_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7253:1: ( ( 'as' ) )
+ // InternalOXtype.g:7254:1: ( 'as' )
+ {
+ // InternalOXtype.g:7254:1: ( 'as' )
+ // InternalOXtype.g:7255:2: 'as'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1());
+ }
+ match(input,60,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCastedExpression__Group_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XPostfixOperation__Group__0"
+ // InternalOXtype.g:7265:1: rule__XPostfixOperation__Group__0 : rule__XPostfixOperation__Group__0__Impl rule__XPostfixOperation__Group__1 ;
+ public final void rule__XPostfixOperation__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7269:1: ( rule__XPostfixOperation__Group__0__Impl rule__XPostfixOperation__Group__1 )
+ // InternalOXtype.g:7270:2: rule__XPostfixOperation__Group__0__Impl rule__XPostfixOperation__Group__1
+ {
+ pushFollow(FOLLOW_46);
+ rule__XPostfixOperation__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XPostfixOperation__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XPostfixOperation__Group__0"
+
+
+ // $ANTLR start "rule__XPostfixOperation__Group__0__Impl"
+ // InternalOXtype.g:7277:1: rule__XPostfixOperation__Group__0__Impl : ( ruleXMemberFeatureCall ) ;
+ public final void rule__XPostfixOperation__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7281:1: ( ( ruleXMemberFeatureCall ) )
+ // InternalOXtype.g:7282:1: ( ruleXMemberFeatureCall )
+ {
+ // InternalOXtype.g:7282:1: ( ruleXMemberFeatureCall )
+ // InternalOXtype.g:7283:2: ruleXMemberFeatureCall
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXMemberFeatureCall();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XPostfixOperation__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XPostfixOperation__Group__1"
+ // InternalOXtype.g:7292:1: rule__XPostfixOperation__Group__1 : rule__XPostfixOperation__Group__1__Impl ;
+ public final void rule__XPostfixOperation__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7296:1: ( rule__XPostfixOperation__Group__1__Impl )
+ // InternalOXtype.g:7297:2: rule__XPostfixOperation__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XPostfixOperation__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XPostfixOperation__Group__1"
+
+
+ // $ANTLR start "rule__XPostfixOperation__Group__1__Impl"
+ // InternalOXtype.g:7303:1: rule__XPostfixOperation__Group__1__Impl : ( ( rule__XPostfixOperation__Group_1__0 )? ) ;
+ public final void rule__XPostfixOperation__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7307:1: ( ( ( rule__XPostfixOperation__Group_1__0 )? ) )
+ // InternalOXtype.g:7308:1: ( ( rule__XPostfixOperation__Group_1__0 )? )
+ {
+ // InternalOXtype.g:7308:1: ( ( rule__XPostfixOperation__Group_1__0 )? )
+ // InternalOXtype.g:7309:2: ( rule__XPostfixOperation__Group_1__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPostfixOperationAccess().getGroup_1());
+ }
+ // InternalOXtype.g:7310:2: ( rule__XPostfixOperation__Group_1__0 )?
+ int alt66=2;
+ int LA66_0 = input.LA(1);
+
+ if ( (LA66_0==41) ) {
+ int LA66_1 = input.LA(2);
+
+ if ( (synpred110_InternalOXtype()) ) {
+ alt66=1;
+ }
+ }
+ else if ( (LA66_0==42) ) {
+ int LA66_2 = input.LA(2);
+
+ if ( (synpred110_InternalOXtype()) ) {
+ alt66=1;
+ }
+ }
+ switch (alt66) {
+ case 1 :
+ // InternalOXtype.g:7310:3: rule__XPostfixOperation__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XPostfixOperation__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPostfixOperationAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XPostfixOperation__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XPostfixOperation__Group_1__0"
+ // InternalOXtype.g:7319:1: rule__XPostfixOperation__Group_1__0 : rule__XPostfixOperation__Group_1__0__Impl ;
+ public final void rule__XPostfixOperation__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7323:1: ( rule__XPostfixOperation__Group_1__0__Impl )
+ // InternalOXtype.g:7324:2: rule__XPostfixOperation__Group_1__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XPostfixOperation__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XPostfixOperation__Group_1__0"
+
+
+ // $ANTLR start "rule__XPostfixOperation__Group_1__0__Impl"
+ // InternalOXtype.g:7330:1: rule__XPostfixOperation__Group_1__0__Impl : ( ( rule__XPostfixOperation__Group_1_0__0 ) ) ;
+ public final void rule__XPostfixOperation__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7334:1: ( ( ( rule__XPostfixOperation__Group_1_0__0 ) ) )
+ // InternalOXtype.g:7335:1: ( ( rule__XPostfixOperation__Group_1_0__0 ) )
+ {
+ // InternalOXtype.g:7335:1: ( ( rule__XPostfixOperation__Group_1_0__0 ) )
+ // InternalOXtype.g:7336:2: ( rule__XPostfixOperation__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPostfixOperationAccess().getGroup_1_0());
+ }
+ // InternalOXtype.g:7337:2: ( rule__XPostfixOperation__Group_1_0__0 )
+ // InternalOXtype.g:7337:3: rule__XPostfixOperation__Group_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XPostfixOperation__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPostfixOperationAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XPostfixOperation__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__XPostfixOperation__Group_1_0__0"
+ // InternalOXtype.g:7346:1: rule__XPostfixOperation__Group_1_0__0 : rule__XPostfixOperation__Group_1_0__0__Impl rule__XPostfixOperation__Group_1_0__1 ;
+ public final void rule__XPostfixOperation__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7350:1: ( rule__XPostfixOperation__Group_1_0__0__Impl rule__XPostfixOperation__Group_1_0__1 )
+ // InternalOXtype.g:7351:2: rule__XPostfixOperation__Group_1_0__0__Impl rule__XPostfixOperation__Group_1_0__1
+ {
+ pushFollow(FOLLOW_46);
+ rule__XPostfixOperation__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XPostfixOperation__Group_1_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XPostfixOperation__Group_1_0__0"
+
+
+ // $ANTLR start "rule__XPostfixOperation__Group_1_0__0__Impl"
+ // InternalOXtype.g:7358:1: rule__XPostfixOperation__Group_1_0__0__Impl : ( () ) ;
+ public final void rule__XPostfixOperation__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7362:1: ( ( () ) )
+ // InternalOXtype.g:7363:1: ( () )
+ {
+ // InternalOXtype.g:7363:1: ( () )
+ // InternalOXtype.g:7364:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0());
+ }
+ // InternalOXtype.g:7365:2: ()
+ // InternalOXtype.g:7365:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XPostfixOperation__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__XPostfixOperation__Group_1_0__1"
+ // InternalOXtype.g:7373:1: rule__XPostfixOperation__Group_1_0__1 : rule__XPostfixOperation__Group_1_0__1__Impl ;
+ public final void rule__XPostfixOperation__Group_1_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7377:1: ( rule__XPostfixOperation__Group_1_0__1__Impl )
+ // InternalOXtype.g:7378:2: rule__XPostfixOperation__Group_1_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XPostfixOperation__Group_1_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XPostfixOperation__Group_1_0__1"
+
+
+ // $ANTLR start "rule__XPostfixOperation__Group_1_0__1__Impl"
+ // InternalOXtype.g:7384:1: rule__XPostfixOperation__Group_1_0__1__Impl : ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) ) ;
+ public final void rule__XPostfixOperation__Group_1_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7388:1: ( ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) ) )
+ // InternalOXtype.g:7389:1: ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) )
+ {
+ // InternalOXtype.g:7389:1: ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) )
+ // InternalOXtype.g:7390:2: ( rule__XPostfixOperation__FeatureAssignment_1_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1());
+ }
+ // InternalOXtype.g:7391:2: ( rule__XPostfixOperation__FeatureAssignment_1_0_1 )
+ // InternalOXtype.g:7391:3: rule__XPostfixOperation__FeatureAssignment_1_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XPostfixOperation__FeatureAssignment_1_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XPostfixOperation__Group_1_0__1__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group__0"
+ // InternalOXtype.g:7400:1: rule__XMemberFeatureCall__Group__0 : rule__XMemberFeatureCall__Group__0__Impl rule__XMemberFeatureCall__Group__1 ;
+ public final void rule__XMemberFeatureCall__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7404:1: ( rule__XMemberFeatureCall__Group__0__Impl rule__XMemberFeatureCall__Group__1 )
+ // InternalOXtype.g:7405:2: rule__XMemberFeatureCall__Group__0__Impl rule__XMemberFeatureCall__Group__1
+ {
+ pushFollow(FOLLOW_47);
+ rule__XMemberFeatureCall__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group__0"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group__0__Impl"
+ // InternalOXtype.g:7412:1: rule__XMemberFeatureCall__Group__0__Impl : ( ruleXPrimaryExpression ) ;
+ public final void rule__XMemberFeatureCall__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7416:1: ( ( ruleXPrimaryExpression ) )
+ // InternalOXtype.g:7417:1: ( ruleXPrimaryExpression )
+ {
+ // InternalOXtype.g:7417:1: ( ruleXPrimaryExpression )
+ // InternalOXtype.g:7418:2: ruleXPrimaryExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXPrimaryExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group__1"
+ // InternalOXtype.g:7427:1: rule__XMemberFeatureCall__Group__1 : rule__XMemberFeatureCall__Group__1__Impl ;
+ public final void rule__XMemberFeatureCall__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7431:1: ( rule__XMemberFeatureCall__Group__1__Impl )
+ // InternalOXtype.g:7432:2: rule__XMemberFeatureCall__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group__1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group__1__Impl"
+ // InternalOXtype.g:7438:1: rule__XMemberFeatureCall__Group__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1 )* ) ;
+ public final void rule__XMemberFeatureCall__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7442:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1 )* ) )
+ // InternalOXtype.g:7443:1: ( ( rule__XMemberFeatureCall__Alternatives_1 )* )
+ {
+ // InternalOXtype.g:7443:1: ( ( rule__XMemberFeatureCall__Alternatives_1 )* )
+ // InternalOXtype.g:7444:2: ( rule__XMemberFeatureCall__Alternatives_1 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1());
+ }
+ // InternalOXtype.g:7445:2: ( rule__XMemberFeatureCall__Alternatives_1 )*
+ loop67:
+ do {
+ int alt67=2;
+ switch ( input.LA(1) ) {
+ case 43:
+ {
+ int LA67_2 = input.LA(2);
+
+ if ( (synpred111_InternalOXtype()) ) {
+ alt67=1;
+ }
+
+
+ }
+ break;
+ case 84:
+ {
+ int LA67_3 = input.LA(2);
+
+ if ( (synpred111_InternalOXtype()) ) {
+ alt67=1;
+ }
+
+
+ }
+ break;
+ case 85:
+ {
+ int LA67_4 = input.LA(2);
+
+ if ( (synpred111_InternalOXtype()) ) {
+ alt67=1;
+ }
+
+
+ }
+ break;
+
+ }
+
+ switch (alt67) {
+ case 1 :
+ // InternalOXtype.g:7445:3: rule__XMemberFeatureCall__Alternatives_1
+ {
+ pushFollow(FOLLOW_48);
+ rule__XMemberFeatureCall__Alternatives_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop67;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__0"
+ // InternalOXtype.g:7454:1: rule__XMemberFeatureCall__Group_1_0__0 : rule__XMemberFeatureCall__Group_1_0__0__Impl rule__XMemberFeatureCall__Group_1_0__1 ;
+ public final void rule__XMemberFeatureCall__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7458:1: ( rule__XMemberFeatureCall__Group_1_0__0__Impl rule__XMemberFeatureCall__Group_1_0__1 )
+ // InternalOXtype.g:7459:2: rule__XMemberFeatureCall__Group_1_0__0__Impl rule__XMemberFeatureCall__Group_1_0__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XMemberFeatureCall__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__0"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__0__Impl"
+ // InternalOXtype.g:7466:1: rule__XMemberFeatureCall__Group_1_0__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) ) ;
+ public final void rule__XMemberFeatureCall__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7470:1: ( ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) ) )
+ // InternalOXtype.g:7471:1: ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) )
+ {
+ // InternalOXtype.g:7471:1: ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) )
+ // InternalOXtype.g:7472:2: ( rule__XMemberFeatureCall__Group_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0());
+ }
+ // InternalOXtype.g:7473:2: ( rule__XMemberFeatureCall__Group_1_0_0__0 )
+ // InternalOXtype.g:7473:3: rule__XMemberFeatureCall__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__1"
+ // InternalOXtype.g:7481:1: rule__XMemberFeatureCall__Group_1_0__1 : rule__XMemberFeatureCall__Group_1_0__1__Impl ;
+ public final void rule__XMemberFeatureCall__Group_1_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7485:1: ( rule__XMemberFeatureCall__Group_1_0__1__Impl )
+ // InternalOXtype.g:7486:2: rule__XMemberFeatureCall__Group_1_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__1__Impl"
+ // InternalOXtype.g:7492:1: rule__XMemberFeatureCall__Group_1_0__1__Impl : ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) ) ;
+ public final void rule__XMemberFeatureCall__Group_1_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7496:1: ( ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) ) )
+ // InternalOXtype.g:7497:1: ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) )
+ {
+ // InternalOXtype.g:7497:1: ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) )
+ // InternalOXtype.g:7498:2: ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1());
+ }
+ // InternalOXtype.g:7499:2: ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 )
+ // InternalOXtype.g:7499:3: rule__XMemberFeatureCall__ValueAssignment_1_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__ValueAssignment_1_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__1__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0__0"
+ // InternalOXtype.g:7508:1: rule__XMemberFeatureCall__Group_1_0_0__0 : rule__XMemberFeatureCall__Group_1_0_0__0__Impl ;
+ public final void rule__XMemberFeatureCall__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7512:1: ( rule__XMemberFeatureCall__Group_1_0_0__0__Impl )
+ // InternalOXtype.g:7513:2: rule__XMemberFeatureCall__Group_1_0_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0__0__Impl"
+ // InternalOXtype.g:7519:1: rule__XMemberFeatureCall__Group_1_0_0__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) ) ;
+ public final void rule__XMemberFeatureCall__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7523:1: ( ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) ) )
+ // InternalOXtype.g:7524:1: ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) )
+ {
+ // InternalOXtype.g:7524:1: ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) )
+ // InternalOXtype.g:7525:2: ( rule__XMemberFeatureCall__Group_1_0_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0());
+ }
+ // InternalOXtype.g:7526:2: ( rule__XMemberFeatureCall__Group_1_0_0_0__0 )
+ // InternalOXtype.g:7526:3: rule__XMemberFeatureCall__Group_1_0_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_0_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__0"
+ // InternalOXtype.g:7535:1: rule__XMemberFeatureCall__Group_1_0_0_0__0 : rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl rule__XMemberFeatureCall__Group_1_0_0_0__1 ;
+ public final void rule__XMemberFeatureCall__Group_1_0_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7539:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl rule__XMemberFeatureCall__Group_1_0_0_0__1 )
+ // InternalOXtype.g:7540:2: rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl rule__XMemberFeatureCall__Group_1_0_0_0__1
+ {
+ pushFollow(FOLLOW_49);
+ rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_0_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__0"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl"
+ // InternalOXtype.g:7547:1: rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl : ( () ) ;
+ public final void rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7551:1: ( ( () ) )
+ // InternalOXtype.g:7552:1: ( () )
+ {
+ // InternalOXtype.g:7552:1: ( () )
+ // InternalOXtype.g:7553:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0());
+ }
+ // InternalOXtype.g:7554:2: ()
+ // InternalOXtype.g:7554:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__1"
+ // InternalOXtype.g:7562:1: rule__XMemberFeatureCall__Group_1_0_0_0__1 : rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl rule__XMemberFeatureCall__Group_1_0_0_0__2 ;
+ public final void rule__XMemberFeatureCall__Group_1_0_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7566:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl rule__XMemberFeatureCall__Group_1_0_0_0__2 )
+ // InternalOXtype.g:7567:2: rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl rule__XMemberFeatureCall__Group_1_0_0_0__2
+ {
+ pushFollow(FOLLOW_20);
+ rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_0_0_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl"
+ // InternalOXtype.g:7574:1: rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) ) ;
+ public final void rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7578:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) ) )
+ // InternalOXtype.g:7579:1: ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) )
+ {
+ // InternalOXtype.g:7579:1: ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) )
+ // InternalOXtype.g:7580:2: ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1());
+ }
+ // InternalOXtype.g:7581:2: ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 )
+ // InternalOXtype.g:7581:3: rule__XMemberFeatureCall__Alternatives_1_0_0_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Alternatives_1_0_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__2"
+ // InternalOXtype.g:7589:1: rule__XMemberFeatureCall__Group_1_0_0_0__2 : rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl rule__XMemberFeatureCall__Group_1_0_0_0__3 ;
+ public final void rule__XMemberFeatureCall__Group_1_0_0_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7593:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl rule__XMemberFeatureCall__Group_1_0_0_0__3 )
+ // InternalOXtype.g:7594:2: rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl rule__XMemberFeatureCall__Group_1_0_0_0__3
+ {
+ pushFollow(FOLLOW_16);
+ rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_0_0_0__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__2"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl"
+ // InternalOXtype.g:7601:1: rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl : ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) ) ;
+ public final void rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7605:1: ( ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) ) )
+ // InternalOXtype.g:7606:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) )
+ {
+ // InternalOXtype.g:7606:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) )
+ // InternalOXtype.g:7607:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2());
+ }
+ // InternalOXtype.g:7608:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 )
+ // InternalOXtype.g:7608:3: rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__3"
+ // InternalOXtype.g:7616:1: rule__XMemberFeatureCall__Group_1_0_0_0__3 : rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl ;
+ public final void rule__XMemberFeatureCall__Group_1_0_0_0__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7620:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl )
+ // InternalOXtype.g:7621:2: rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__3"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl"
+ // InternalOXtype.g:7627:1: rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl : ( ruleOpSingleAssign ) ;
+ public final void rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7631:1: ( ( ruleOpSingleAssign ) )
+ // InternalOXtype.g:7632:1: ( ruleOpSingleAssign )
+ {
+ // InternalOXtype.g:7632:1: ( ruleOpSingleAssign )
+ // InternalOXtype.g:7633:2: ruleOpSingleAssign
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3());
+ }
+ pushFollow(FOLLOW_2);
+ ruleOpSingleAssign();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__0"
+ // InternalOXtype.g:7643:1: rule__XMemberFeatureCall__Group_1_1__0 : rule__XMemberFeatureCall__Group_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1__1 ;
+ public final void rule__XMemberFeatureCall__Group_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7647:1: ( rule__XMemberFeatureCall__Group_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1__1 )
+ // InternalOXtype.g:7648:2: rule__XMemberFeatureCall__Group_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1__1
+ {
+ pushFollow(FOLLOW_50);
+ rule__XMemberFeatureCall__Group_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__0"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__0__Impl"
+ // InternalOXtype.g:7655:1: rule__XMemberFeatureCall__Group_1_1__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7659:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) ) )
+ // InternalOXtype.g:7660:1: ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) )
+ {
+ // InternalOXtype.g:7660:1: ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) )
+ // InternalOXtype.g:7661:2: ( rule__XMemberFeatureCall__Group_1_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0());
+ }
+ // InternalOXtype.g:7662:2: ( rule__XMemberFeatureCall__Group_1_1_0__0 )
+ // InternalOXtype.g:7662:3: rule__XMemberFeatureCall__Group_1_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__1"
+ // InternalOXtype.g:7670:1: rule__XMemberFeatureCall__Group_1_1__1 : rule__XMemberFeatureCall__Group_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1__2 ;
+ public final void rule__XMemberFeatureCall__Group_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7674:1: ( rule__XMemberFeatureCall__Group_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1__2 )
+ // InternalOXtype.g:7675:2: rule__XMemberFeatureCall__Group_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1__2
+ {
+ pushFollow(FOLLOW_50);
+ rule__XMemberFeatureCall__Group_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__1__Impl"
+ // InternalOXtype.g:7682:1: rule__XMemberFeatureCall__Group_1_1__1__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7686:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? ) )
+ // InternalOXtype.g:7687:1: ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? )
+ {
+ // InternalOXtype.g:7687:1: ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? )
+ // InternalOXtype.g:7688:2: ( rule__XMemberFeatureCall__Group_1_1_1__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1());
+ }
+ // InternalOXtype.g:7689:2: ( rule__XMemberFeatureCall__Group_1_1_1__0 )?
+ int alt68=2;
+ int LA68_0 = input.LA(1);
+
+ if ( (LA68_0==27) ) {
+ alt68=1;
+ }
+ switch (alt68) {
+ case 1 :
+ // InternalOXtype.g:7689:3: rule__XMemberFeatureCall__Group_1_1_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__2"
+ // InternalOXtype.g:7697:1: rule__XMemberFeatureCall__Group_1_1__2 : rule__XMemberFeatureCall__Group_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1__3 ;
+ public final void rule__XMemberFeatureCall__Group_1_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7701:1: ( rule__XMemberFeatureCall__Group_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1__3 )
+ // InternalOXtype.g:7702:2: rule__XMemberFeatureCall__Group_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1__3
+ {
+ pushFollow(FOLLOW_51);
+ rule__XMemberFeatureCall__Group_1_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__2"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__2__Impl"
+ // InternalOXtype.g:7709:1: rule__XMemberFeatureCall__Group_1_1__2__Impl : ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7713:1: ( ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) ) )
+ // InternalOXtype.g:7714:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) )
+ {
+ // InternalOXtype.g:7714:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) )
+ // InternalOXtype.g:7715:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2());
+ }
+ // InternalOXtype.g:7716:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 )
+ // InternalOXtype.g:7716:3: rule__XMemberFeatureCall__FeatureAssignment_1_1_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__FeatureAssignment_1_1_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__2__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__3"
+ // InternalOXtype.g:7724:1: rule__XMemberFeatureCall__Group_1_1__3 : rule__XMemberFeatureCall__Group_1_1__3__Impl rule__XMemberFeatureCall__Group_1_1__4 ;
+ public final void rule__XMemberFeatureCall__Group_1_1__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7728:1: ( rule__XMemberFeatureCall__Group_1_1__3__Impl rule__XMemberFeatureCall__Group_1_1__4 )
+ // InternalOXtype.g:7729:2: rule__XMemberFeatureCall__Group_1_1__3__Impl rule__XMemberFeatureCall__Group_1_1__4
+ {
+ pushFollow(FOLLOW_51);
+ rule__XMemberFeatureCall__Group_1_1__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__3"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__3__Impl"
+ // InternalOXtype.g:7736:1: rule__XMemberFeatureCall__Group_1_1__3__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7740:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? ) )
+ // InternalOXtype.g:7741:1: ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? )
+ {
+ // InternalOXtype.g:7741:1: ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? )
+ // InternalOXtype.g:7742:2: ( rule__XMemberFeatureCall__Group_1_1_3__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3());
+ }
+ // InternalOXtype.g:7743:2: ( rule__XMemberFeatureCall__Group_1_1_3__0 )?
+ int alt69=2;
+ alt69 = dfa69.predict(input);
+ switch (alt69) {
+ case 1 :
+ // InternalOXtype.g:7743:3: rule__XMemberFeatureCall__Group_1_1_3__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__3__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__4"
+ // InternalOXtype.g:7751:1: rule__XMemberFeatureCall__Group_1_1__4 : rule__XMemberFeatureCall__Group_1_1__4__Impl ;
+ public final void rule__XMemberFeatureCall__Group_1_1__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7755:1: ( rule__XMemberFeatureCall__Group_1_1__4__Impl )
+ // InternalOXtype.g:7756:2: rule__XMemberFeatureCall__Group_1_1__4__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__4"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__4__Impl"
+ // InternalOXtype.g:7762:1: rule__XMemberFeatureCall__Group_1_1__4__Impl : ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7766:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? ) )
+ // InternalOXtype.g:7767:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? )
+ {
+ // InternalOXtype.g:7767:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? )
+ // InternalOXtype.g:7768:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4());
+ }
+ // InternalOXtype.g:7769:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )?
+ int alt70=2;
+ alt70 = dfa70.predict(input);
+ switch (alt70) {
+ case 1 :
+ // InternalOXtype.g:7769:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__4__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0__0"
+ // InternalOXtype.g:7778:1: rule__XMemberFeatureCall__Group_1_1_0__0 : rule__XMemberFeatureCall__Group_1_1_0__0__Impl ;
+ public final void rule__XMemberFeatureCall__Group_1_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7782:1: ( rule__XMemberFeatureCall__Group_1_1_0__0__Impl )
+ // InternalOXtype.g:7783:2: rule__XMemberFeatureCall__Group_1_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0__0"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0__0__Impl"
+ // InternalOXtype.g:7789:1: rule__XMemberFeatureCall__Group_1_1_0__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7793:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) ) )
+ // InternalOXtype.g:7794:1: ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) )
+ {
+ // InternalOXtype.g:7794:1: ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) )
+ // InternalOXtype.g:7795:2: ( rule__XMemberFeatureCall__Group_1_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0());
+ }
+ // InternalOXtype.g:7796:2: ( rule__XMemberFeatureCall__Group_1_1_0_0__0 )
+ // InternalOXtype.g:7796:3: rule__XMemberFeatureCall__Group_1_1_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__0"
+ // InternalOXtype.g:7805:1: rule__XMemberFeatureCall__Group_1_1_0_0__0 : rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl rule__XMemberFeatureCall__Group_1_1_0_0__1 ;
+ public final void rule__XMemberFeatureCall__Group_1_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7809:1: ( rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl rule__XMemberFeatureCall__Group_1_1_0_0__1 )
+ // InternalOXtype.g:7810:2: rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl rule__XMemberFeatureCall__Group_1_1_0_0__1
+ {
+ pushFollow(FOLLOW_47);
+ rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__0"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl"
+ // InternalOXtype.g:7817:1: rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl : ( () ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7821:1: ( ( () ) )
+ // InternalOXtype.g:7822:1: ( () )
+ {
+ // InternalOXtype.g:7822:1: ( () )
+ // InternalOXtype.g:7823:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0());
+ }
+ // InternalOXtype.g:7824:2: ()
+ // InternalOXtype.g:7824:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__1"
+ // InternalOXtype.g:7832:1: rule__XMemberFeatureCall__Group_1_1_0_0__1 : rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl ;
+ public final void rule__XMemberFeatureCall__Group_1_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7836:1: ( rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl )
+ // InternalOXtype.g:7837:2: rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl"
+ // InternalOXtype.g:7843:1: rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7847:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) ) )
+ // InternalOXtype.g:7848:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) )
+ {
+ // InternalOXtype.g:7848:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) )
+ // InternalOXtype.g:7849:2: ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1());
+ }
+ // InternalOXtype.g:7850:2: ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 )
+ // InternalOXtype.g:7850:3: rule__XMemberFeatureCall__Alternatives_1_1_0_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Alternatives_1_1_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__0"
+ // InternalOXtype.g:7859:1: rule__XMemberFeatureCall__Group_1_1_1__0 : rule__XMemberFeatureCall__Group_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_1__1 ;
+ public final void rule__XMemberFeatureCall__Group_1_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7863:1: ( rule__XMemberFeatureCall__Group_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_1__1 )
+ // InternalOXtype.g:7864:2: rule__XMemberFeatureCall__Group_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_1__1
+ {
+ pushFollow(FOLLOW_52);
+ rule__XMemberFeatureCall__Group_1_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__0"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__0__Impl"
+ // InternalOXtype.g:7871:1: rule__XMemberFeatureCall__Group_1_1_1__0__Impl : ( '<' ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7875:1: ( ( '<' ) )
+ // InternalOXtype.g:7876:1: ( '<' )
+ {
+ // InternalOXtype.g:7876:1: ( '<' )
+ // InternalOXtype.g:7877:2: '<'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0());
+ }
+ match(input,27,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__1"
+ // InternalOXtype.g:7886:1: rule__XMemberFeatureCall__Group_1_1_1__1 : rule__XMemberFeatureCall__Group_1_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1_1__2 ;
+ public final void rule__XMemberFeatureCall__Group_1_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7890:1: ( rule__XMemberFeatureCall__Group_1_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1_1__2 )
+ // InternalOXtype.g:7891:2: rule__XMemberFeatureCall__Group_1_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1_1__2
+ {
+ pushFollow(FOLLOW_53);
+ rule__XMemberFeatureCall__Group_1_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__1__Impl"
+ // InternalOXtype.g:7898:1: rule__XMemberFeatureCall__Group_1_1_1__1__Impl : ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7902:1: ( ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) ) )
+ // InternalOXtype.g:7903:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) )
+ {
+ // InternalOXtype.g:7903:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) )
+ // InternalOXtype.g:7904:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1());
+ }
+ // InternalOXtype.g:7905:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 )
+ // InternalOXtype.g:7905:3: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__2"
+ // InternalOXtype.g:7913:1: rule__XMemberFeatureCall__Group_1_1_1__2 : rule__XMemberFeatureCall__Group_1_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1_1__3 ;
+ public final void rule__XMemberFeatureCall__Group_1_1_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7917:1: ( rule__XMemberFeatureCall__Group_1_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1_1__3 )
+ // InternalOXtype.g:7918:2: rule__XMemberFeatureCall__Group_1_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1_1__3
+ {
+ pushFollow(FOLLOW_53);
+ rule__XMemberFeatureCall__Group_1_1_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_1__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__2"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__2__Impl"
+ // InternalOXtype.g:7925:1: rule__XMemberFeatureCall__Group_1_1_1__2__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7929:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* ) )
+ // InternalOXtype.g:7930:1: ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* )
+ {
+ // InternalOXtype.g:7930:1: ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* )
+ // InternalOXtype.g:7931:2: ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2());
+ }
+ // InternalOXtype.g:7932:2: ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )*
+ loop71:
+ do {
+ int alt71=2;
+ int LA71_0 = input.LA(1);
+
+ if ( (LA71_0==55) ) {
+ alt71=1;
+ }
+
+
+ switch (alt71) {
+ case 1 :
+ // InternalOXtype.g:7932:3: rule__XMemberFeatureCall__Group_1_1_1_2__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XMemberFeatureCall__Group_1_1_1_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop71;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__2__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__3"
+ // InternalOXtype.g:7940:1: rule__XMemberFeatureCall__Group_1_1_1__3 : rule__XMemberFeatureCall__Group_1_1_1__3__Impl ;
+ public final void rule__XMemberFeatureCall__Group_1_1_1__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7944:1: ( rule__XMemberFeatureCall__Group_1_1_1__3__Impl )
+ // InternalOXtype.g:7945:2: rule__XMemberFeatureCall__Group_1_1_1__3__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_1__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__3"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__3__Impl"
+ // InternalOXtype.g:7951:1: rule__XMemberFeatureCall__Group_1_1_1__3__Impl : ( '>' ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1_1__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7955:1: ( ( '>' ) )
+ // InternalOXtype.g:7956:1: ( '>' )
+ {
+ // InternalOXtype.g:7956:1: ( '>' )
+ // InternalOXtype.g:7957:2: '>'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3());
+ }
+ match(input,26,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__3__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__0"
+ // InternalOXtype.g:7967:1: rule__XMemberFeatureCall__Group_1_1_1_2__0 : rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl rule__XMemberFeatureCall__Group_1_1_1_2__1 ;
+ public final void rule__XMemberFeatureCall__Group_1_1_1_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7971:1: ( rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl rule__XMemberFeatureCall__Group_1_1_1_2__1 )
+ // InternalOXtype.g:7972:2: rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl rule__XMemberFeatureCall__Group_1_1_1_2__1
+ {
+ pushFollow(FOLLOW_52);
+ rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_1_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__0"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl"
+ // InternalOXtype.g:7979:1: rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl : ( ',' ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7983:1: ( ( ',' ) )
+ // InternalOXtype.g:7984:1: ( ',' )
+ {
+ // InternalOXtype.g:7984:1: ( ',' )
+ // InternalOXtype.g:7985:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__1"
+ // InternalOXtype.g:7994:1: rule__XMemberFeatureCall__Group_1_1_1_2__1 : rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl ;
+ public final void rule__XMemberFeatureCall__Group_1_1_1_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:7998:1: ( rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl )
+ // InternalOXtype.g:7999:2: rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl"
+ // InternalOXtype.g:8005:1: rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl : ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8009:1: ( ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) ) )
+ // InternalOXtype.g:8010:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) )
+ {
+ // InternalOXtype.g:8010:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) )
+ // InternalOXtype.g:8011:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1());
+ }
+ // InternalOXtype.g:8012:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 )
+ // InternalOXtype.g:8012:3: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__0"
+ // InternalOXtype.g:8021:1: rule__XMemberFeatureCall__Group_1_1_3__0 : rule__XMemberFeatureCall__Group_1_1_3__0__Impl rule__XMemberFeatureCall__Group_1_1_3__1 ;
+ public final void rule__XMemberFeatureCall__Group_1_1_3__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8025:1: ( rule__XMemberFeatureCall__Group_1_1_3__0__Impl rule__XMemberFeatureCall__Group_1_1_3__1 )
+ // InternalOXtype.g:8026:2: rule__XMemberFeatureCall__Group_1_1_3__0__Impl rule__XMemberFeatureCall__Group_1_1_3__1
+ {
+ pushFollow(FOLLOW_54);
+ rule__XMemberFeatureCall__Group_1_1_3__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_3__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__0"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__0__Impl"
+ // InternalOXtype.g:8033:1: rule__XMemberFeatureCall__Group_1_1_3__0__Impl : ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1_3__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8037:1: ( ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) ) )
+ // InternalOXtype.g:8038:1: ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) )
+ {
+ // InternalOXtype.g:8038:1: ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) )
+ // InternalOXtype.g:8039:2: ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0());
+ }
+ // InternalOXtype.g:8040:2: ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 )
+ // InternalOXtype.g:8040:3: rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__0__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__1"
+ // InternalOXtype.g:8048:1: rule__XMemberFeatureCall__Group_1_1_3__1 : rule__XMemberFeatureCall__Group_1_1_3__1__Impl rule__XMemberFeatureCall__Group_1_1_3__2 ;
+ public final void rule__XMemberFeatureCall__Group_1_1_3__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8052:1: ( rule__XMemberFeatureCall__Group_1_1_3__1__Impl rule__XMemberFeatureCall__Group_1_1_3__2 )
+ // InternalOXtype.g:8053:2: rule__XMemberFeatureCall__Group_1_1_3__1__Impl rule__XMemberFeatureCall__Group_1_1_3__2
+ {
+ pushFollow(FOLLOW_54);
+ rule__XMemberFeatureCall__Group_1_1_3__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_3__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__1__Impl"
+ // InternalOXtype.g:8060:1: rule__XMemberFeatureCall__Group_1_1_3__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1_3__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8064:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? ) )
+ // InternalOXtype.g:8065:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? )
+ {
+ // InternalOXtype.g:8065:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? )
+ // InternalOXtype.g:8066:2: ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1());
+ }
+ // InternalOXtype.g:8067:2: ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )?
+ int alt72=2;
+ int LA72_0 = input.LA(1);
+
+ if ( ((LA72_0>=RULE_ID && LA72_0<=RULE_STRING)||LA72_0==27||LA72_0==31||(LA72_0>=34 && LA72_0<=35)||LA72_0==40||(LA72_0>=45 && LA72_0<=50)||LA72_0==53||(LA72_0>=57 && LA72_0<=58)||LA72_0==61||LA72_0==63||LA72_0==65||(LA72_0>=69 && LA72_0<=77)||LA72_0==79||LA72_0==86||LA72_0==88) ) {
+ alt72=1;
+ }
+ switch (alt72) {
+ case 1 :
+ // InternalOXtype.g:8067:3: rule__XMemberFeatureCall__Alternatives_1_1_3_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Alternatives_1_1_3_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__1__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__2"
+ // InternalOXtype.g:8075:1: rule__XMemberFeatureCall__Group_1_1_3__2 : rule__XMemberFeatureCall__Group_1_1_3__2__Impl ;
+ public final void rule__XMemberFeatureCall__Group_1_1_3__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8079:1: ( rule__XMemberFeatureCall__Group_1_1_3__2__Impl )
+ // InternalOXtype.g:8080:2: rule__XMemberFeatureCall__Group_1_1_3__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_3__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__2"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__2__Impl"
+ // InternalOXtype.g:8086:1: rule__XMemberFeatureCall__Group_1_1_3__2__Impl : ( ')' ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1_3__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8090:1: ( ( ')' ) )
+ // InternalOXtype.g:8091:1: ( ')' )
+ {
+ // InternalOXtype.g:8091:1: ( ')' )
+ // InternalOXtype.g:8092:2: ')'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2());
+ }
+ match(input,54,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__2__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__0"
+ // InternalOXtype.g:8102:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__0 : rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1__1 ;
+ public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8106:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1__1 )
+ // InternalOXtype.g:8107:2: rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1__1
+ {
+ pushFollow(FOLLOW_13);
+ rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_3_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__0"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl"
+ // InternalOXtype.g:8114:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl : ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8118:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) ) )
+ // InternalOXtype.g:8119:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) )
+ {
+ // InternalOXtype.g:8119:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) )
+ // InternalOXtype.g:8120:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0());
+ }
+ // InternalOXtype.g:8121:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 )
+ // InternalOXtype.g:8121:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__1"
+ // InternalOXtype.g:8129:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__1 : rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl ;
+ public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8133:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl )
+ // InternalOXtype.g:8134:2: rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl"
+ // InternalOXtype.g:8140:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8144:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* ) )
+ // InternalOXtype.g:8145:1: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* )
+ {
+ // InternalOXtype.g:8145:1: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* )
+ // InternalOXtype.g:8146:2: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1());
+ }
+ // InternalOXtype.g:8147:2: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )*
+ loop73:
+ do {
+ int alt73=2;
+ int LA73_0 = input.LA(1);
+
+ if ( (LA73_0==55) ) {
+ alt73=1;
+ }
+
+
+ switch (alt73) {
+ case 1 :
+ // InternalOXtype.g:8147:3: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop73;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0"
+ // InternalOXtype.g:8156:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 : rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 ;
+ public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8160:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 )
+ // InternalOXtype.g:8161:2: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl"
+ // InternalOXtype.g:8168:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl : ( ',' ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8172:1: ( ( ',' ) )
+ // InternalOXtype.g:8173:1: ( ',' )
+ {
+ // InternalOXtype.g:8173:1: ( ',' )
+ // InternalOXtype.g:8174:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1"
+ // InternalOXtype.g:8183:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 : rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl ;
+ public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8187:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl )
+ // InternalOXtype.g:8188:2: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl"
+ // InternalOXtype.g:8194:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl : ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) ) ;
+ public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8198:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) ) )
+ // InternalOXtype.g:8199:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) )
+ {
+ // InternalOXtype.g:8199:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) )
+ // InternalOXtype.g:8200:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1());
+ }
+ // InternalOXtype.g:8201:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 )
+ // InternalOXtype.g:8201:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group__0"
+ // InternalOXtype.g:8210:1: rule__XSetLiteral__Group__0 : rule__XSetLiteral__Group__0__Impl rule__XSetLiteral__Group__1 ;
+ public final void rule__XSetLiteral__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8214:1: ( rule__XSetLiteral__Group__0__Impl rule__XSetLiteral__Group__1 )
+ // InternalOXtype.g:8215:2: rule__XSetLiteral__Group__0__Impl rule__XSetLiteral__Group__1
+ {
+ pushFollow(FOLLOW_18);
+ rule__XSetLiteral__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSetLiteral__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group__0"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group__0__Impl"
+ // InternalOXtype.g:8222:1: rule__XSetLiteral__Group__0__Impl : ( () ) ;
+ public final void rule__XSetLiteral__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8226:1: ( ( () ) )
+ // InternalOXtype.g:8227:1: ( () )
+ {
+ // InternalOXtype.g:8227:1: ( () )
+ // InternalOXtype.g:8228:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0());
+ }
+ // InternalOXtype.g:8229:2: ()
+ // InternalOXtype.g:8229:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group__1"
+ // InternalOXtype.g:8237:1: rule__XSetLiteral__Group__1 : rule__XSetLiteral__Group__1__Impl rule__XSetLiteral__Group__2 ;
+ public final void rule__XSetLiteral__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8241:1: ( rule__XSetLiteral__Group__1__Impl rule__XSetLiteral__Group__2 )
+ // InternalOXtype.g:8242:2: rule__XSetLiteral__Group__1__Impl rule__XSetLiteral__Group__2
+ {
+ pushFollow(FOLLOW_55);
+ rule__XSetLiteral__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSetLiteral__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group__1"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group__1__Impl"
+ // InternalOXtype.g:8249:1: rule__XSetLiteral__Group__1__Impl : ( '#' ) ;
+ public final void rule__XSetLiteral__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8253:1: ( ( '#' ) )
+ // InternalOXtype.g:8254:1: ( '#' )
+ {
+ // InternalOXtype.g:8254:1: ( '#' )
+ // InternalOXtype.g:8255:2: '#'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1());
+ }
+ match(input,57,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group__2"
+ // InternalOXtype.g:8264:1: rule__XSetLiteral__Group__2 : rule__XSetLiteral__Group__2__Impl rule__XSetLiteral__Group__3 ;
+ public final void rule__XSetLiteral__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8268:1: ( rule__XSetLiteral__Group__2__Impl rule__XSetLiteral__Group__3 )
+ // InternalOXtype.g:8269:2: rule__XSetLiteral__Group__2__Impl rule__XSetLiteral__Group__3
+ {
+ pushFollow(FOLLOW_56);
+ rule__XSetLiteral__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSetLiteral__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group__2"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group__2__Impl"
+ // InternalOXtype.g:8276:1: rule__XSetLiteral__Group__2__Impl : ( '{' ) ;
+ public final void rule__XSetLiteral__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8280:1: ( ( '{' ) )
+ // InternalOXtype.g:8281:1: ( '{' )
+ {
+ // InternalOXtype.g:8281:1: ( '{' )
+ // InternalOXtype.g:8282:2: '{'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2());
+ }
+ match(input,61,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group__3"
+ // InternalOXtype.g:8291:1: rule__XSetLiteral__Group__3 : rule__XSetLiteral__Group__3__Impl rule__XSetLiteral__Group__4 ;
+ public final void rule__XSetLiteral__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8295:1: ( rule__XSetLiteral__Group__3__Impl rule__XSetLiteral__Group__4 )
+ // InternalOXtype.g:8296:2: rule__XSetLiteral__Group__3__Impl rule__XSetLiteral__Group__4
+ {
+ pushFollow(FOLLOW_56);
+ rule__XSetLiteral__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSetLiteral__Group__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group__3"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group__3__Impl"
+ // InternalOXtype.g:8303:1: rule__XSetLiteral__Group__3__Impl : ( ( rule__XSetLiteral__Group_3__0 )? ) ;
+ public final void rule__XSetLiteral__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8307:1: ( ( ( rule__XSetLiteral__Group_3__0 )? ) )
+ // InternalOXtype.g:8308:1: ( ( rule__XSetLiteral__Group_3__0 )? )
+ {
+ // InternalOXtype.g:8308:1: ( ( rule__XSetLiteral__Group_3__0 )? )
+ // InternalOXtype.g:8309:2: ( rule__XSetLiteral__Group_3__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSetLiteralAccess().getGroup_3());
+ }
+ // InternalOXtype.g:8310:2: ( rule__XSetLiteral__Group_3__0 )?
+ int alt74=2;
+ int LA74_0 = input.LA(1);
+
+ if ( ((LA74_0>=RULE_ID && LA74_0<=RULE_STRING)||LA74_0==27||(LA74_0>=34 && LA74_0<=35)||LA74_0==40||(LA74_0>=45 && LA74_0<=50)||LA74_0==53||(LA74_0>=57 && LA74_0<=58)||LA74_0==61||LA74_0==63||LA74_0==65||(LA74_0>=69 && LA74_0<=77)||LA74_0==79||LA74_0==88) ) {
+ alt74=1;
+ }
+ switch (alt74) {
+ case 1 :
+ // InternalOXtype.g:8310:3: rule__XSetLiteral__Group_3__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSetLiteral__Group_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSetLiteralAccess().getGroup_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group__4"
+ // InternalOXtype.g:8318:1: rule__XSetLiteral__Group__4 : rule__XSetLiteral__Group__4__Impl ;
+ public final void rule__XSetLiteral__Group__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8322:1: ( rule__XSetLiteral__Group__4__Impl )
+ // InternalOXtype.g:8323:2: rule__XSetLiteral__Group__4__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSetLiteral__Group__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group__4"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group__4__Impl"
+ // InternalOXtype.g:8329:1: rule__XSetLiteral__Group__4__Impl : ( '}' ) ;
+ public final void rule__XSetLiteral__Group__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8333:1: ( ( '}' ) )
+ // InternalOXtype.g:8334:1: ( '}' )
+ {
+ // InternalOXtype.g:8334:1: ( '}' )
+ // InternalOXtype.g:8335:2: '}'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4());
+ }
+ match(input,62,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group__4__Impl"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group_3__0"
+ // InternalOXtype.g:8345:1: rule__XSetLiteral__Group_3__0 : rule__XSetLiteral__Group_3__0__Impl rule__XSetLiteral__Group_3__1 ;
+ public final void rule__XSetLiteral__Group_3__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8349:1: ( rule__XSetLiteral__Group_3__0__Impl rule__XSetLiteral__Group_3__1 )
+ // InternalOXtype.g:8350:2: rule__XSetLiteral__Group_3__0__Impl rule__XSetLiteral__Group_3__1
+ {
+ pushFollow(FOLLOW_13);
+ rule__XSetLiteral__Group_3__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSetLiteral__Group_3__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group_3__0"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group_3__0__Impl"
+ // InternalOXtype.g:8357:1: rule__XSetLiteral__Group_3__0__Impl : ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) ) ;
+ public final void rule__XSetLiteral__Group_3__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8361:1: ( ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) ) )
+ // InternalOXtype.g:8362:1: ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) )
+ {
+ // InternalOXtype.g:8362:1: ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) )
+ // InternalOXtype.g:8363:2: ( rule__XSetLiteral__ElementsAssignment_3_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0());
+ }
+ // InternalOXtype.g:8364:2: ( rule__XSetLiteral__ElementsAssignment_3_0 )
+ // InternalOXtype.g:8364:3: rule__XSetLiteral__ElementsAssignment_3_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSetLiteral__ElementsAssignment_3_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group_3__0__Impl"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group_3__1"
+ // InternalOXtype.g:8372:1: rule__XSetLiteral__Group_3__1 : rule__XSetLiteral__Group_3__1__Impl ;
+ public final void rule__XSetLiteral__Group_3__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8376:1: ( rule__XSetLiteral__Group_3__1__Impl )
+ // InternalOXtype.g:8377:2: rule__XSetLiteral__Group_3__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSetLiteral__Group_3__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group_3__1"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group_3__1__Impl"
+ // InternalOXtype.g:8383:1: rule__XSetLiteral__Group_3__1__Impl : ( ( rule__XSetLiteral__Group_3_1__0 )* ) ;
+ public final void rule__XSetLiteral__Group_3__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8387:1: ( ( ( rule__XSetLiteral__Group_3_1__0 )* ) )
+ // InternalOXtype.g:8388:1: ( ( rule__XSetLiteral__Group_3_1__0 )* )
+ {
+ // InternalOXtype.g:8388:1: ( ( rule__XSetLiteral__Group_3_1__0 )* )
+ // InternalOXtype.g:8389:2: ( rule__XSetLiteral__Group_3_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSetLiteralAccess().getGroup_3_1());
+ }
+ // InternalOXtype.g:8390:2: ( rule__XSetLiteral__Group_3_1__0 )*
+ loop75:
+ do {
+ int alt75=2;
+ int LA75_0 = input.LA(1);
+
+ if ( (LA75_0==55) ) {
+ alt75=1;
+ }
+
+
+ switch (alt75) {
+ case 1 :
+ // InternalOXtype.g:8390:3: rule__XSetLiteral__Group_3_1__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XSetLiteral__Group_3_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop75;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSetLiteralAccess().getGroup_3_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group_3__1__Impl"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group_3_1__0"
+ // InternalOXtype.g:8399:1: rule__XSetLiteral__Group_3_1__0 : rule__XSetLiteral__Group_3_1__0__Impl rule__XSetLiteral__Group_3_1__1 ;
+ public final void rule__XSetLiteral__Group_3_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8403:1: ( rule__XSetLiteral__Group_3_1__0__Impl rule__XSetLiteral__Group_3_1__1 )
+ // InternalOXtype.g:8404:2: rule__XSetLiteral__Group_3_1__0__Impl rule__XSetLiteral__Group_3_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XSetLiteral__Group_3_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSetLiteral__Group_3_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group_3_1__0"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group_3_1__0__Impl"
+ // InternalOXtype.g:8411:1: rule__XSetLiteral__Group_3_1__0__Impl : ( ',' ) ;
+ public final void rule__XSetLiteral__Group_3_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8415:1: ( ( ',' ) )
+ // InternalOXtype.g:8416:1: ( ',' )
+ {
+ // InternalOXtype.g:8416:1: ( ',' )
+ // InternalOXtype.g:8417:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group_3_1__0__Impl"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group_3_1__1"
+ // InternalOXtype.g:8426:1: rule__XSetLiteral__Group_3_1__1 : rule__XSetLiteral__Group_3_1__1__Impl ;
+ public final void rule__XSetLiteral__Group_3_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8430:1: ( rule__XSetLiteral__Group_3_1__1__Impl )
+ // InternalOXtype.g:8431:2: rule__XSetLiteral__Group_3_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSetLiteral__Group_3_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group_3_1__1"
+
+
+ // $ANTLR start "rule__XSetLiteral__Group_3_1__1__Impl"
+ // InternalOXtype.g:8437:1: rule__XSetLiteral__Group_3_1__1__Impl : ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) ) ;
+ public final void rule__XSetLiteral__Group_3_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8441:1: ( ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) ) )
+ // InternalOXtype.g:8442:1: ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) )
+ {
+ // InternalOXtype.g:8442:1: ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) )
+ // InternalOXtype.g:8443:2: ( rule__XSetLiteral__ElementsAssignment_3_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1());
+ }
+ // InternalOXtype.g:8444:2: ( rule__XSetLiteral__ElementsAssignment_3_1_1 )
+ // InternalOXtype.g:8444:3: rule__XSetLiteral__ElementsAssignment_3_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSetLiteral__ElementsAssignment_3_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__Group_3_1__1__Impl"
+
+
+ // $ANTLR start "rule__XListLiteral__Group__0"
+ // InternalOXtype.g:8453:1: rule__XListLiteral__Group__0 : rule__XListLiteral__Group__0__Impl rule__XListLiteral__Group__1 ;
+ public final void rule__XListLiteral__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8457:1: ( rule__XListLiteral__Group__0__Impl rule__XListLiteral__Group__1 )
+ // InternalOXtype.g:8458:2: rule__XListLiteral__Group__0__Impl rule__XListLiteral__Group__1
+ {
+ pushFollow(FOLLOW_18);
+ rule__XListLiteral__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XListLiteral__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group__0"
+
+
+ // $ANTLR start "rule__XListLiteral__Group__0__Impl"
+ // InternalOXtype.g:8465:1: rule__XListLiteral__Group__0__Impl : ( () ) ;
+ public final void rule__XListLiteral__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8469:1: ( ( () ) )
+ // InternalOXtype.g:8470:1: ( () )
+ {
+ // InternalOXtype.g:8470:1: ( () )
+ // InternalOXtype.g:8471:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0());
+ }
+ // InternalOXtype.g:8472:2: ()
+ // InternalOXtype.g:8472:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XListLiteral__Group__1"
+ // InternalOXtype.g:8480:1: rule__XListLiteral__Group__1 : rule__XListLiteral__Group__1__Impl rule__XListLiteral__Group__2 ;
+ public final void rule__XListLiteral__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8484:1: ( rule__XListLiteral__Group__1__Impl rule__XListLiteral__Group__2 )
+ // InternalOXtype.g:8485:2: rule__XListLiteral__Group__1__Impl rule__XListLiteral__Group__2
+ {
+ pushFollow(FOLLOW_19);
+ rule__XListLiteral__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XListLiteral__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group__1"
+
+
+ // $ANTLR start "rule__XListLiteral__Group__1__Impl"
+ // InternalOXtype.g:8492:1: rule__XListLiteral__Group__1__Impl : ( '#' ) ;
+ public final void rule__XListLiteral__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8496:1: ( ( '#' ) )
+ // InternalOXtype.g:8497:1: ( '#' )
+ {
+ // InternalOXtype.g:8497:1: ( '#' )
+ // InternalOXtype.g:8498:2: '#'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1());
+ }
+ match(input,57,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XListLiteral__Group__2"
+ // InternalOXtype.g:8507:1: rule__XListLiteral__Group__2 : rule__XListLiteral__Group__2__Impl rule__XListLiteral__Group__3 ;
+ public final void rule__XListLiteral__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8511:1: ( rule__XListLiteral__Group__2__Impl rule__XListLiteral__Group__3 )
+ // InternalOXtype.g:8512:2: rule__XListLiteral__Group__2__Impl rule__XListLiteral__Group__3
+ {
+ pushFollow(FOLLOW_17);
+ rule__XListLiteral__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XListLiteral__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group__2"
+
+
+ // $ANTLR start "rule__XListLiteral__Group__2__Impl"
+ // InternalOXtype.g:8519:1: rule__XListLiteral__Group__2__Impl : ( '[' ) ;
+ public final void rule__XListLiteral__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8523:1: ( ( '[' ) )
+ // InternalOXtype.g:8524:1: ( '[' )
+ {
+ // InternalOXtype.g:8524:1: ( '[' )
+ // InternalOXtype.g:8525:2: '['
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2());
+ }
+ match(input,58,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XListLiteral__Group__3"
+ // InternalOXtype.g:8534:1: rule__XListLiteral__Group__3 : rule__XListLiteral__Group__3__Impl rule__XListLiteral__Group__4 ;
+ public final void rule__XListLiteral__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8538:1: ( rule__XListLiteral__Group__3__Impl rule__XListLiteral__Group__4 )
+ // InternalOXtype.g:8539:2: rule__XListLiteral__Group__3__Impl rule__XListLiteral__Group__4
+ {
+ pushFollow(FOLLOW_17);
+ rule__XListLiteral__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XListLiteral__Group__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group__3"
+
+
+ // $ANTLR start "rule__XListLiteral__Group__3__Impl"
+ // InternalOXtype.g:8546:1: rule__XListLiteral__Group__3__Impl : ( ( rule__XListLiteral__Group_3__0 )? ) ;
+ public final void rule__XListLiteral__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8550:1: ( ( ( rule__XListLiteral__Group_3__0 )? ) )
+ // InternalOXtype.g:8551:1: ( ( rule__XListLiteral__Group_3__0 )? )
+ {
+ // InternalOXtype.g:8551:1: ( ( rule__XListLiteral__Group_3__0 )? )
+ // InternalOXtype.g:8552:2: ( rule__XListLiteral__Group_3__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXListLiteralAccess().getGroup_3());
+ }
+ // InternalOXtype.g:8553:2: ( rule__XListLiteral__Group_3__0 )?
+ int alt76=2;
+ int LA76_0 = input.LA(1);
+
+ if ( ((LA76_0>=RULE_ID && LA76_0<=RULE_STRING)||LA76_0==27||(LA76_0>=34 && LA76_0<=35)||LA76_0==40||(LA76_0>=45 && LA76_0<=50)||LA76_0==53||(LA76_0>=57 && LA76_0<=58)||LA76_0==61||LA76_0==63||LA76_0==65||(LA76_0>=69 && LA76_0<=77)||LA76_0==79||LA76_0==88) ) {
+ alt76=1;
+ }
+ switch (alt76) {
+ case 1 :
+ // InternalOXtype.g:8553:3: rule__XListLiteral__Group_3__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XListLiteral__Group_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXListLiteralAccess().getGroup_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XListLiteral__Group__4"
+ // InternalOXtype.g:8561:1: rule__XListLiteral__Group__4 : rule__XListLiteral__Group__4__Impl ;
+ public final void rule__XListLiteral__Group__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8565:1: ( rule__XListLiteral__Group__4__Impl )
+ // InternalOXtype.g:8566:2: rule__XListLiteral__Group__4__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XListLiteral__Group__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group__4"
+
+
+ // $ANTLR start "rule__XListLiteral__Group__4__Impl"
+ // InternalOXtype.g:8572:1: rule__XListLiteral__Group__4__Impl : ( ']' ) ;
+ public final void rule__XListLiteral__Group__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8576:1: ( ( ']' ) )
+ // InternalOXtype.g:8577:1: ( ']' )
+ {
+ // InternalOXtype.g:8577:1: ( ']' )
+ // InternalOXtype.g:8578:2: ']'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4());
+ }
+ match(input,56,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group__4__Impl"
+
+
+ // $ANTLR start "rule__XListLiteral__Group_3__0"
+ // InternalOXtype.g:8588:1: rule__XListLiteral__Group_3__0 : rule__XListLiteral__Group_3__0__Impl rule__XListLiteral__Group_3__1 ;
+ public final void rule__XListLiteral__Group_3__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8592:1: ( rule__XListLiteral__Group_3__0__Impl rule__XListLiteral__Group_3__1 )
+ // InternalOXtype.g:8593:2: rule__XListLiteral__Group_3__0__Impl rule__XListLiteral__Group_3__1
+ {
+ pushFollow(FOLLOW_13);
+ rule__XListLiteral__Group_3__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XListLiteral__Group_3__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group_3__0"
+
+
+ // $ANTLR start "rule__XListLiteral__Group_3__0__Impl"
+ // InternalOXtype.g:8600:1: rule__XListLiteral__Group_3__0__Impl : ( ( rule__XListLiteral__ElementsAssignment_3_0 ) ) ;
+ public final void rule__XListLiteral__Group_3__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8604:1: ( ( ( rule__XListLiteral__ElementsAssignment_3_0 ) ) )
+ // InternalOXtype.g:8605:1: ( ( rule__XListLiteral__ElementsAssignment_3_0 ) )
+ {
+ // InternalOXtype.g:8605:1: ( ( rule__XListLiteral__ElementsAssignment_3_0 ) )
+ // InternalOXtype.g:8606:2: ( rule__XListLiteral__ElementsAssignment_3_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0());
+ }
+ // InternalOXtype.g:8607:2: ( rule__XListLiteral__ElementsAssignment_3_0 )
+ // InternalOXtype.g:8607:3: rule__XListLiteral__ElementsAssignment_3_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XListLiteral__ElementsAssignment_3_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group_3__0__Impl"
+
+
+ // $ANTLR start "rule__XListLiteral__Group_3__1"
+ // InternalOXtype.g:8615:1: rule__XListLiteral__Group_3__1 : rule__XListLiteral__Group_3__1__Impl ;
+ public final void rule__XListLiteral__Group_3__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8619:1: ( rule__XListLiteral__Group_3__1__Impl )
+ // InternalOXtype.g:8620:2: rule__XListLiteral__Group_3__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XListLiteral__Group_3__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group_3__1"
+
+
+ // $ANTLR start "rule__XListLiteral__Group_3__1__Impl"
+ // InternalOXtype.g:8626:1: rule__XListLiteral__Group_3__1__Impl : ( ( rule__XListLiteral__Group_3_1__0 )* ) ;
+ public final void rule__XListLiteral__Group_3__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8630:1: ( ( ( rule__XListLiteral__Group_3_1__0 )* ) )
+ // InternalOXtype.g:8631:1: ( ( rule__XListLiteral__Group_3_1__0 )* )
+ {
+ // InternalOXtype.g:8631:1: ( ( rule__XListLiteral__Group_3_1__0 )* )
+ // InternalOXtype.g:8632:2: ( rule__XListLiteral__Group_3_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXListLiteralAccess().getGroup_3_1());
+ }
+ // InternalOXtype.g:8633:2: ( rule__XListLiteral__Group_3_1__0 )*
+ loop77:
+ do {
+ int alt77=2;
+ int LA77_0 = input.LA(1);
+
+ if ( (LA77_0==55) ) {
+ alt77=1;
+ }
+
+
+ switch (alt77) {
+ case 1 :
+ // InternalOXtype.g:8633:3: rule__XListLiteral__Group_3_1__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XListLiteral__Group_3_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop77;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXListLiteralAccess().getGroup_3_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group_3__1__Impl"
+
+
+ // $ANTLR start "rule__XListLiteral__Group_3_1__0"
+ // InternalOXtype.g:8642:1: rule__XListLiteral__Group_3_1__0 : rule__XListLiteral__Group_3_1__0__Impl rule__XListLiteral__Group_3_1__1 ;
+ public final void rule__XListLiteral__Group_3_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8646:1: ( rule__XListLiteral__Group_3_1__0__Impl rule__XListLiteral__Group_3_1__1 )
+ // InternalOXtype.g:8647:2: rule__XListLiteral__Group_3_1__0__Impl rule__XListLiteral__Group_3_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XListLiteral__Group_3_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XListLiteral__Group_3_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group_3_1__0"
+
+
+ // $ANTLR start "rule__XListLiteral__Group_3_1__0__Impl"
+ // InternalOXtype.g:8654:1: rule__XListLiteral__Group_3_1__0__Impl : ( ',' ) ;
+ public final void rule__XListLiteral__Group_3_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8658:1: ( ( ',' ) )
+ // InternalOXtype.g:8659:1: ( ',' )
+ {
+ // InternalOXtype.g:8659:1: ( ',' )
+ // InternalOXtype.g:8660:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group_3_1__0__Impl"
+
+
+ // $ANTLR start "rule__XListLiteral__Group_3_1__1"
+ // InternalOXtype.g:8669:1: rule__XListLiteral__Group_3_1__1 : rule__XListLiteral__Group_3_1__1__Impl ;
+ public final void rule__XListLiteral__Group_3_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8673:1: ( rule__XListLiteral__Group_3_1__1__Impl )
+ // InternalOXtype.g:8674:2: rule__XListLiteral__Group_3_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XListLiteral__Group_3_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group_3_1__1"
+
+
+ // $ANTLR start "rule__XListLiteral__Group_3_1__1__Impl"
+ // InternalOXtype.g:8680:1: rule__XListLiteral__Group_3_1__1__Impl : ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) ) ;
+ public final void rule__XListLiteral__Group_3_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8684:1: ( ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) ) )
+ // InternalOXtype.g:8685:1: ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) )
+ {
+ // InternalOXtype.g:8685:1: ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) )
+ // InternalOXtype.g:8686:2: ( rule__XListLiteral__ElementsAssignment_3_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1());
+ }
+ // InternalOXtype.g:8687:2: ( rule__XListLiteral__ElementsAssignment_3_1_1 )
+ // InternalOXtype.g:8687:3: rule__XListLiteral__ElementsAssignment_3_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XListLiteral__ElementsAssignment_3_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__Group_3_1__1__Impl"
+
+
+ // $ANTLR start "rule__XClosure__Group__0"
+ // InternalOXtype.g:8696:1: rule__XClosure__Group__0 : rule__XClosure__Group__0__Impl rule__XClosure__Group__1 ;
+ public final void rule__XClosure__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8700:1: ( rule__XClosure__Group__0__Impl rule__XClosure__Group__1 )
+ // InternalOXtype.g:8701:2: rule__XClosure__Group__0__Impl rule__XClosure__Group__1
+ {
+ pushFollow(FOLLOW_57);
+ rule__XClosure__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group__0"
+
+
+ // $ANTLR start "rule__XClosure__Group__0__Impl"
+ // InternalOXtype.g:8708:1: rule__XClosure__Group__0__Impl : ( ( rule__XClosure__Group_0__0 ) ) ;
+ public final void rule__XClosure__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8712:1: ( ( ( rule__XClosure__Group_0__0 ) ) )
+ // InternalOXtype.g:8713:1: ( ( rule__XClosure__Group_0__0 ) )
+ {
+ // InternalOXtype.g:8713:1: ( ( rule__XClosure__Group_0__0 ) )
+ // InternalOXtype.g:8714:2: ( rule__XClosure__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getGroup_0());
+ }
+ // InternalOXtype.g:8715:2: ( rule__XClosure__Group_0__0 )
+ // InternalOXtype.g:8715:3: rule__XClosure__Group_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XClosure__Group__1"
+ // InternalOXtype.g:8723:1: rule__XClosure__Group__1 : rule__XClosure__Group__1__Impl rule__XClosure__Group__2 ;
+ public final void rule__XClosure__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8727:1: ( rule__XClosure__Group__1__Impl rule__XClosure__Group__2 )
+ // InternalOXtype.g:8728:2: rule__XClosure__Group__1__Impl rule__XClosure__Group__2
+ {
+ pushFollow(FOLLOW_57);
+ rule__XClosure__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group__1"
+
+
+ // $ANTLR start "rule__XClosure__Group__1__Impl"
+ // InternalOXtype.g:8735:1: rule__XClosure__Group__1__Impl : ( ( rule__XClosure__Group_1__0 )? ) ;
+ public final void rule__XClosure__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8739:1: ( ( ( rule__XClosure__Group_1__0 )? ) )
+ // InternalOXtype.g:8740:1: ( ( rule__XClosure__Group_1__0 )? )
+ {
+ // InternalOXtype.g:8740:1: ( ( rule__XClosure__Group_1__0 )? )
+ // InternalOXtype.g:8741:2: ( rule__XClosure__Group_1__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getGroup_1());
+ }
+ // InternalOXtype.g:8742:2: ( rule__XClosure__Group_1__0 )?
+ int alt78=2;
+ alt78 = dfa78.predict(input);
+ switch (alt78) {
+ case 1 :
+ // InternalOXtype.g:8742:3: rule__XClosure__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XClosure__Group__2"
+ // InternalOXtype.g:8750:1: rule__XClosure__Group__2 : rule__XClosure__Group__2__Impl rule__XClosure__Group__3 ;
+ public final void rule__XClosure__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8754:1: ( rule__XClosure__Group__2__Impl rule__XClosure__Group__3 )
+ // InternalOXtype.g:8755:2: rule__XClosure__Group__2__Impl rule__XClosure__Group__3
+ {
+ pushFollow(FOLLOW_58);
+ rule__XClosure__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group__2"
+
+
+ // $ANTLR start "rule__XClosure__Group__2__Impl"
+ // InternalOXtype.g:8762:1: rule__XClosure__Group__2__Impl : ( ( rule__XClosure__ExpressionAssignment_2 ) ) ;
+ public final void rule__XClosure__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8766:1: ( ( ( rule__XClosure__ExpressionAssignment_2 ) ) )
+ // InternalOXtype.g:8767:1: ( ( rule__XClosure__ExpressionAssignment_2 ) )
+ {
+ // InternalOXtype.g:8767:1: ( ( rule__XClosure__ExpressionAssignment_2 ) )
+ // InternalOXtype.g:8768:2: ( rule__XClosure__ExpressionAssignment_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getExpressionAssignment_2());
+ }
+ // InternalOXtype.g:8769:2: ( rule__XClosure__ExpressionAssignment_2 )
+ // InternalOXtype.g:8769:3: rule__XClosure__ExpressionAssignment_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__ExpressionAssignment_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getExpressionAssignment_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XClosure__Group__3"
+ // InternalOXtype.g:8777:1: rule__XClosure__Group__3 : rule__XClosure__Group__3__Impl ;
+ public final void rule__XClosure__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8781:1: ( rule__XClosure__Group__3__Impl )
+ // InternalOXtype.g:8782:2: rule__XClosure__Group__3__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group__3"
+
+
+ // $ANTLR start "rule__XClosure__Group__3__Impl"
+ // InternalOXtype.g:8788:1: rule__XClosure__Group__3__Impl : ( ']' ) ;
+ public final void rule__XClosure__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8792:1: ( ( ']' ) )
+ // InternalOXtype.g:8793:1: ( ']' )
+ {
+ // InternalOXtype.g:8793:1: ( ']' )
+ // InternalOXtype.g:8794:2: ']'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3());
+ }
+ match(input,56,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XClosure__Group_0__0"
+ // InternalOXtype.g:8804:1: rule__XClosure__Group_0__0 : rule__XClosure__Group_0__0__Impl ;
+ public final void rule__XClosure__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8808:1: ( rule__XClosure__Group_0__0__Impl )
+ // InternalOXtype.g:8809:2: rule__XClosure__Group_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_0__0"
+
+
+ // $ANTLR start "rule__XClosure__Group_0__0__Impl"
+ // InternalOXtype.g:8815:1: rule__XClosure__Group_0__0__Impl : ( ( rule__XClosure__Group_0_0__0 ) ) ;
+ public final void rule__XClosure__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8819:1: ( ( ( rule__XClosure__Group_0_0__0 ) ) )
+ // InternalOXtype.g:8820:1: ( ( rule__XClosure__Group_0_0__0 ) )
+ {
+ // InternalOXtype.g:8820:1: ( ( rule__XClosure__Group_0_0__0 ) )
+ // InternalOXtype.g:8821:2: ( rule__XClosure__Group_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getGroup_0_0());
+ }
+ // InternalOXtype.g:8822:2: ( rule__XClosure__Group_0_0__0 )
+ // InternalOXtype.g:8822:3: rule__XClosure__Group_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getGroup_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__XClosure__Group_0_0__0"
+ // InternalOXtype.g:8831:1: rule__XClosure__Group_0_0__0 : rule__XClosure__Group_0_0__0__Impl rule__XClosure__Group_0_0__1 ;
+ public final void rule__XClosure__Group_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8835:1: ( rule__XClosure__Group_0_0__0__Impl rule__XClosure__Group_0_0__1 )
+ // InternalOXtype.g:8836:2: rule__XClosure__Group_0_0__0__Impl rule__XClosure__Group_0_0__1
+ {
+ pushFollow(FOLLOW_19);
+ rule__XClosure__Group_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_0_0__0"
+
+
+ // $ANTLR start "rule__XClosure__Group_0_0__0__Impl"
+ // InternalOXtype.g:8843:1: rule__XClosure__Group_0_0__0__Impl : ( () ) ;
+ public final void rule__XClosure__Group_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8847:1: ( ( () ) )
+ // InternalOXtype.g:8848:1: ( () )
+ {
+ // InternalOXtype.g:8848:1: ( () )
+ // InternalOXtype.g:8849:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0());
+ }
+ // InternalOXtype.g:8850:2: ()
+ // InternalOXtype.g:8850:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XClosure__Group_0_0__1"
+ // InternalOXtype.g:8858:1: rule__XClosure__Group_0_0__1 : rule__XClosure__Group_0_0__1__Impl ;
+ public final void rule__XClosure__Group_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8862:1: ( rule__XClosure__Group_0_0__1__Impl )
+ // InternalOXtype.g:8863:2: rule__XClosure__Group_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_0_0__1"
+
+
+ // $ANTLR start "rule__XClosure__Group_0_0__1__Impl"
+ // InternalOXtype.g:8869:1: rule__XClosure__Group_0_0__1__Impl : ( '[' ) ;
+ public final void rule__XClosure__Group_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8873:1: ( ( '[' ) )
+ // InternalOXtype.g:8874:1: ( '[' )
+ {
+ // InternalOXtype.g:8874:1: ( '[' )
+ // InternalOXtype.g:8875:2: '['
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1());
+ }
+ match(input,58,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XClosure__Group_1__0"
+ // InternalOXtype.g:8885:1: rule__XClosure__Group_1__0 : rule__XClosure__Group_1__0__Impl ;
+ public final void rule__XClosure__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8889:1: ( rule__XClosure__Group_1__0__Impl )
+ // InternalOXtype.g:8890:2: rule__XClosure__Group_1__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_1__0"
+
+
+ // $ANTLR start "rule__XClosure__Group_1__0__Impl"
+ // InternalOXtype.g:8896:1: rule__XClosure__Group_1__0__Impl : ( ( rule__XClosure__Group_1_0__0 ) ) ;
+ public final void rule__XClosure__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8900:1: ( ( ( rule__XClosure__Group_1_0__0 ) ) )
+ // InternalOXtype.g:8901:1: ( ( rule__XClosure__Group_1_0__0 ) )
+ {
+ // InternalOXtype.g:8901:1: ( ( rule__XClosure__Group_1_0__0 ) )
+ // InternalOXtype.g:8902:2: ( rule__XClosure__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getGroup_1_0());
+ }
+ // InternalOXtype.g:8903:2: ( rule__XClosure__Group_1_0__0 )
+ // InternalOXtype.g:8903:3: rule__XClosure__Group_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__XClosure__Group_1_0__0"
+ // InternalOXtype.g:8912:1: rule__XClosure__Group_1_0__0 : rule__XClosure__Group_1_0__0__Impl rule__XClosure__Group_1_0__1 ;
+ public final void rule__XClosure__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8916:1: ( rule__XClosure__Group_1_0__0__Impl rule__XClosure__Group_1_0__1 )
+ // InternalOXtype.g:8917:2: rule__XClosure__Group_1_0__0__Impl rule__XClosure__Group_1_0__1
+ {
+ pushFollow(FOLLOW_59);
+ rule__XClosure__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group_1_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_1_0__0"
+
+
+ // $ANTLR start "rule__XClosure__Group_1_0__0__Impl"
+ // InternalOXtype.g:8924:1: rule__XClosure__Group_1_0__0__Impl : ( ( rule__XClosure__Group_1_0_0__0 )? ) ;
+ public final void rule__XClosure__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8928:1: ( ( ( rule__XClosure__Group_1_0_0__0 )? ) )
+ // InternalOXtype.g:8929:1: ( ( rule__XClosure__Group_1_0_0__0 )? )
+ {
+ // InternalOXtype.g:8929:1: ( ( rule__XClosure__Group_1_0_0__0 )? )
+ // InternalOXtype.g:8930:2: ( rule__XClosure__Group_1_0_0__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getGroup_1_0_0());
+ }
+ // InternalOXtype.g:8931:2: ( rule__XClosure__Group_1_0_0__0 )?
+ int alt79=2;
+ int LA79_0 = input.LA(1);
+
+ if ( (LA79_0==RULE_ID||LA79_0==31||LA79_0==53) ) {
+ alt79=1;
+ }
+ switch (alt79) {
+ case 1 :
+ // InternalOXtype.g:8931:3: rule__XClosure__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__XClosure__Group_1_0__1"
+ // InternalOXtype.g:8939:1: rule__XClosure__Group_1_0__1 : rule__XClosure__Group_1_0__1__Impl ;
+ public final void rule__XClosure__Group_1_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8943:1: ( rule__XClosure__Group_1_0__1__Impl )
+ // InternalOXtype.g:8944:2: rule__XClosure__Group_1_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group_1_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_1_0__1"
+
+
+ // $ANTLR start "rule__XClosure__Group_1_0__1__Impl"
+ // InternalOXtype.g:8950:1: rule__XClosure__Group_1_0__1__Impl : ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) ) ;
+ public final void rule__XClosure__Group_1_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8954:1: ( ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) ) )
+ // InternalOXtype.g:8955:1: ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) )
+ {
+ // InternalOXtype.g:8955:1: ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) )
+ // InternalOXtype.g:8956:2: ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1());
+ }
+ // InternalOXtype.g:8957:2: ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 )
+ // InternalOXtype.g:8957:3: rule__XClosure__ExplicitSyntaxAssignment_1_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__ExplicitSyntaxAssignment_1_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_1_0__1__Impl"
+
+
+ // $ANTLR start "rule__XClosure__Group_1_0_0__0"
+ // InternalOXtype.g:8966:1: rule__XClosure__Group_1_0_0__0 : rule__XClosure__Group_1_0_0__0__Impl rule__XClosure__Group_1_0_0__1 ;
+ public final void rule__XClosure__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8970:1: ( rule__XClosure__Group_1_0_0__0__Impl rule__XClosure__Group_1_0_0__1 )
+ // InternalOXtype.g:8971:2: rule__XClosure__Group_1_0_0__0__Impl rule__XClosure__Group_1_0_0__1
+ {
+ pushFollow(FOLLOW_13);
+ rule__XClosure__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__XClosure__Group_1_0_0__0__Impl"
+ // InternalOXtype.g:8978:1: rule__XClosure__Group_1_0_0__0__Impl : ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) ) ;
+ public final void rule__XClosure__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8982:1: ( ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) ) )
+ // InternalOXtype.g:8983:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) )
+ {
+ // InternalOXtype.g:8983:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) )
+ // InternalOXtype.g:8984:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0());
+ }
+ // InternalOXtype.g:8985:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 )
+ // InternalOXtype.g:8985:3: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XClosure__Group_1_0_0__1"
+ // InternalOXtype.g:8993:1: rule__XClosure__Group_1_0_0__1 : rule__XClosure__Group_1_0_0__1__Impl ;
+ public final void rule__XClosure__Group_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:8997:1: ( rule__XClosure__Group_1_0_0__1__Impl )
+ // InternalOXtype.g:8998:2: rule__XClosure__Group_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_1_0_0__1"
+
+
+ // $ANTLR start "rule__XClosure__Group_1_0_0__1__Impl"
+ // InternalOXtype.g:9004:1: rule__XClosure__Group_1_0_0__1__Impl : ( ( rule__XClosure__Group_1_0_0_1__0 )* ) ;
+ public final void rule__XClosure__Group_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9008:1: ( ( ( rule__XClosure__Group_1_0_0_1__0 )* ) )
+ // InternalOXtype.g:9009:1: ( ( rule__XClosure__Group_1_0_0_1__0 )* )
+ {
+ // InternalOXtype.g:9009:1: ( ( rule__XClosure__Group_1_0_0_1__0 )* )
+ // InternalOXtype.g:9010:2: ( rule__XClosure__Group_1_0_0_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getGroup_1_0_0_1());
+ }
+ // InternalOXtype.g:9011:2: ( rule__XClosure__Group_1_0_0_1__0 )*
+ loop80:
+ do {
+ int alt80=2;
+ int LA80_0 = input.LA(1);
+
+ if ( (LA80_0==55) ) {
+ alt80=1;
+ }
+
+
+ switch (alt80) {
+ case 1 :
+ // InternalOXtype.g:9011:3: rule__XClosure__Group_1_0_0_1__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XClosure__Group_1_0_0_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop80;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getGroup_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XClosure__Group_1_0_0_1__0"
+ // InternalOXtype.g:9020:1: rule__XClosure__Group_1_0_0_1__0 : rule__XClosure__Group_1_0_0_1__0__Impl rule__XClosure__Group_1_0_0_1__1 ;
+ public final void rule__XClosure__Group_1_0_0_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9024:1: ( rule__XClosure__Group_1_0_0_1__0__Impl rule__XClosure__Group_1_0_0_1__1 )
+ // InternalOXtype.g:9025:2: rule__XClosure__Group_1_0_0_1__0__Impl rule__XClosure__Group_1_0_0_1__1
+ {
+ pushFollow(FOLLOW_32);
+ rule__XClosure__Group_1_0_0_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group_1_0_0_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_1_0_0_1__0"
+
+
+ // $ANTLR start "rule__XClosure__Group_1_0_0_1__0__Impl"
+ // InternalOXtype.g:9032:1: rule__XClosure__Group_1_0_0_1__0__Impl : ( ',' ) ;
+ public final void rule__XClosure__Group_1_0_0_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9036:1: ( ( ',' ) )
+ // InternalOXtype.g:9037:1: ( ',' )
+ {
+ // InternalOXtype.g:9037:1: ( ',' )
+ // InternalOXtype.g:9038:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_1_0_0_1__0__Impl"
+
+
+ // $ANTLR start "rule__XClosure__Group_1_0_0_1__1"
+ // InternalOXtype.g:9047:1: rule__XClosure__Group_1_0_0_1__1 : rule__XClosure__Group_1_0_0_1__1__Impl ;
+ public final void rule__XClosure__Group_1_0_0_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9051:1: ( rule__XClosure__Group_1_0_0_1__1__Impl )
+ // InternalOXtype.g:9052:2: rule__XClosure__Group_1_0_0_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group_1_0_0_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_1_0_0_1__1"
+
+
+ // $ANTLR start "rule__XClosure__Group_1_0_0_1__1__Impl"
+ // InternalOXtype.g:9058:1: rule__XClosure__Group_1_0_0_1__1__Impl : ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) ) ;
+ public final void rule__XClosure__Group_1_0_0_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9062:1: ( ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) ) )
+ // InternalOXtype.g:9063:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) )
+ {
+ // InternalOXtype.g:9063:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) )
+ // InternalOXtype.g:9064:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1());
+ }
+ // InternalOXtype.g:9065:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 )
+ // InternalOXtype.g:9065:3: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__Group_1_0_0_1__1__Impl"
+
+
+ // $ANTLR start "rule__XExpressionInClosure__Group__0"
+ // InternalOXtype.g:9074:1: rule__XExpressionInClosure__Group__0 : rule__XExpressionInClosure__Group__0__Impl rule__XExpressionInClosure__Group__1 ;
+ public final void rule__XExpressionInClosure__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9078:1: ( rule__XExpressionInClosure__Group__0__Impl rule__XExpressionInClosure__Group__1 )
+ // InternalOXtype.g:9079:2: rule__XExpressionInClosure__Group__0__Impl rule__XExpressionInClosure__Group__1
+ {
+ pushFollow(FOLLOW_57);
+ rule__XExpressionInClosure__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XExpressionInClosure__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XExpressionInClosure__Group__0"
+
+
+ // $ANTLR start "rule__XExpressionInClosure__Group__0__Impl"
+ // InternalOXtype.g:9086:1: rule__XExpressionInClosure__Group__0__Impl : ( () ) ;
+ public final void rule__XExpressionInClosure__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9090:1: ( ( () ) )
+ // InternalOXtype.g:9091:1: ( () )
+ {
+ // InternalOXtype.g:9091:1: ( () )
+ // InternalOXtype.g:9092:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0());
+ }
+ // InternalOXtype.g:9093:2: ()
+ // InternalOXtype.g:9093:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XExpressionInClosure__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XExpressionInClosure__Group__1"
+ // InternalOXtype.g:9101:1: rule__XExpressionInClosure__Group__1 : rule__XExpressionInClosure__Group__1__Impl ;
+ public final void rule__XExpressionInClosure__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9105:1: ( rule__XExpressionInClosure__Group__1__Impl )
+ // InternalOXtype.g:9106:2: rule__XExpressionInClosure__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XExpressionInClosure__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XExpressionInClosure__Group__1"
+
+
+ // $ANTLR start "rule__XExpressionInClosure__Group__1__Impl"
+ // InternalOXtype.g:9112:1: rule__XExpressionInClosure__Group__1__Impl : ( ( rule__XExpressionInClosure__Group_1__0 )* ) ;
+ public final void rule__XExpressionInClosure__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9116:1: ( ( ( rule__XExpressionInClosure__Group_1__0 )* ) )
+ // InternalOXtype.g:9117:1: ( ( rule__XExpressionInClosure__Group_1__0 )* )
+ {
+ // InternalOXtype.g:9117:1: ( ( rule__XExpressionInClosure__Group_1__0 )* )
+ // InternalOXtype.g:9118:2: ( rule__XExpressionInClosure__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXExpressionInClosureAccess().getGroup_1());
+ }
+ // InternalOXtype.g:9119:2: ( rule__XExpressionInClosure__Group_1__0 )*
+ loop81:
+ do {
+ int alt81=2;
+ int LA81_0 = input.LA(1);
+
+ if ( ((LA81_0>=RULE_ID && LA81_0<=RULE_STRING)||LA81_0==27||(LA81_0>=34 && LA81_0<=35)||LA81_0==40||(LA81_0>=44 && LA81_0<=50)||LA81_0==53||(LA81_0>=57 && LA81_0<=58)||LA81_0==61||LA81_0==63||LA81_0==65||(LA81_0>=69 && LA81_0<=77)||LA81_0==79||(LA81_0>=87 && LA81_0<=88)) ) {
+ alt81=1;
+ }
+
+
+ switch (alt81) {
+ case 1 :
+ // InternalOXtype.g:9119:3: rule__XExpressionInClosure__Group_1__0
+ {
+ pushFollow(FOLLOW_60);
+ rule__XExpressionInClosure__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop81;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXExpressionInClosureAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XExpressionInClosure__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XExpressionInClosure__Group_1__0"
+ // InternalOXtype.g:9128:1: rule__XExpressionInClosure__Group_1__0 : rule__XExpressionInClosure__Group_1__0__Impl rule__XExpressionInClosure__Group_1__1 ;
+ public final void rule__XExpressionInClosure__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9132:1: ( rule__XExpressionInClosure__Group_1__0__Impl rule__XExpressionInClosure__Group_1__1 )
+ // InternalOXtype.g:9133:2: rule__XExpressionInClosure__Group_1__0__Impl rule__XExpressionInClosure__Group_1__1
+ {
+ pushFollow(FOLLOW_6);
+ rule__XExpressionInClosure__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XExpressionInClosure__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XExpressionInClosure__Group_1__0"
+
+
+ // $ANTLR start "rule__XExpressionInClosure__Group_1__0__Impl"
+ // InternalOXtype.g:9140:1: rule__XExpressionInClosure__Group_1__0__Impl : ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) ) ;
+ public final void rule__XExpressionInClosure__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9144:1: ( ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) ) )
+ // InternalOXtype.g:9145:1: ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) )
+ {
+ // InternalOXtype.g:9145:1: ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) )
+ // InternalOXtype.g:9146:2: ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0());
+ }
+ // InternalOXtype.g:9147:2: ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 )
+ // InternalOXtype.g:9147:3: rule__XExpressionInClosure__ExpressionsAssignment_1_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XExpressionInClosure__ExpressionsAssignment_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XExpressionInClosure__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__XExpressionInClosure__Group_1__1"
+ // InternalOXtype.g:9155:1: rule__XExpressionInClosure__Group_1__1 : rule__XExpressionInClosure__Group_1__1__Impl ;
+ public final void rule__XExpressionInClosure__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9159:1: ( rule__XExpressionInClosure__Group_1__1__Impl )
+ // InternalOXtype.g:9160:2: rule__XExpressionInClosure__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XExpressionInClosure__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XExpressionInClosure__Group_1__1"
+
+
+ // $ANTLR start "rule__XExpressionInClosure__Group_1__1__Impl"
+ // InternalOXtype.g:9166:1: rule__XExpressionInClosure__Group_1__1__Impl : ( ( ';' )? ) ;
+ public final void rule__XExpressionInClosure__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9170:1: ( ( ( ';' )? ) )
+ // InternalOXtype.g:9171:1: ( ( ';' )? )
+ {
+ // InternalOXtype.g:9171:1: ( ( ';' )? )
+ // InternalOXtype.g:9172:2: ( ';' )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1());
+ }
+ // InternalOXtype.g:9173:2: ( ';' )?
+ int alt82=2;
+ int LA82_0 = input.LA(1);
+
+ if ( (LA82_0==51) ) {
+ alt82=1;
+ }
+ switch (alt82) {
+ case 1 :
+ // InternalOXtype.g:9173:3: ';'
+ {
+ match(input,51,FOLLOW_2); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XExpressionInClosure__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__XShortClosure__Group__0"
+ // InternalOXtype.g:9182:1: rule__XShortClosure__Group__0 : rule__XShortClosure__Group__0__Impl rule__XShortClosure__Group__1 ;
+ public final void rule__XShortClosure__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9186:1: ( rule__XShortClosure__Group__0__Impl rule__XShortClosure__Group__1 )
+ // InternalOXtype.g:9187:2: rule__XShortClosure__Group__0__Impl rule__XShortClosure__Group__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XShortClosure__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group__0"
+
+
+ // $ANTLR start "rule__XShortClosure__Group__0__Impl"
+ // InternalOXtype.g:9194:1: rule__XShortClosure__Group__0__Impl : ( ( rule__XShortClosure__Group_0__0 ) ) ;
+ public final void rule__XShortClosure__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9198:1: ( ( ( rule__XShortClosure__Group_0__0 ) ) )
+ // InternalOXtype.g:9199:1: ( ( rule__XShortClosure__Group_0__0 ) )
+ {
+ // InternalOXtype.g:9199:1: ( ( rule__XShortClosure__Group_0__0 ) )
+ // InternalOXtype.g:9200:2: ( rule__XShortClosure__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXShortClosureAccess().getGroup_0());
+ }
+ // InternalOXtype.g:9201:2: ( rule__XShortClosure__Group_0__0 )
+ // InternalOXtype.g:9201:3: rule__XShortClosure__Group_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXShortClosureAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XShortClosure__Group__1"
+ // InternalOXtype.g:9209:1: rule__XShortClosure__Group__1 : rule__XShortClosure__Group__1__Impl ;
+ public final void rule__XShortClosure__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9213:1: ( rule__XShortClosure__Group__1__Impl )
+ // InternalOXtype.g:9214:2: rule__XShortClosure__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group__1"
+
+
+ // $ANTLR start "rule__XShortClosure__Group__1__Impl"
+ // InternalOXtype.g:9220:1: rule__XShortClosure__Group__1__Impl : ( ( rule__XShortClosure__ExpressionAssignment_1 ) ) ;
+ public final void rule__XShortClosure__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9224:1: ( ( ( rule__XShortClosure__ExpressionAssignment_1 ) ) )
+ // InternalOXtype.g:9225:1: ( ( rule__XShortClosure__ExpressionAssignment_1 ) )
+ {
+ // InternalOXtype.g:9225:1: ( ( rule__XShortClosure__ExpressionAssignment_1 ) )
+ // InternalOXtype.g:9226:2: ( rule__XShortClosure__ExpressionAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1());
+ }
+ // InternalOXtype.g:9227:2: ( rule__XShortClosure__ExpressionAssignment_1 )
+ // InternalOXtype.g:9227:3: rule__XShortClosure__ExpressionAssignment_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__ExpressionAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XShortClosure__Group_0__0"
+ // InternalOXtype.g:9236:1: rule__XShortClosure__Group_0__0 : rule__XShortClosure__Group_0__0__Impl ;
+ public final void rule__XShortClosure__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9240:1: ( rule__XShortClosure__Group_0__0__Impl )
+ // InternalOXtype.g:9241:2: rule__XShortClosure__Group_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group_0__0"
+
+
+ // $ANTLR start "rule__XShortClosure__Group_0__0__Impl"
+ // InternalOXtype.g:9247:1: rule__XShortClosure__Group_0__0__Impl : ( ( rule__XShortClosure__Group_0_0__0 ) ) ;
+ public final void rule__XShortClosure__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9251:1: ( ( ( rule__XShortClosure__Group_0_0__0 ) ) )
+ // InternalOXtype.g:9252:1: ( ( rule__XShortClosure__Group_0_0__0 ) )
+ {
+ // InternalOXtype.g:9252:1: ( ( rule__XShortClosure__Group_0_0__0 ) )
+ // InternalOXtype.g:9253:2: ( rule__XShortClosure__Group_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXShortClosureAccess().getGroup_0_0());
+ }
+ // InternalOXtype.g:9254:2: ( rule__XShortClosure__Group_0_0__0 )
+ // InternalOXtype.g:9254:3: rule__XShortClosure__Group_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__Group_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXShortClosureAccess().getGroup_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__XShortClosure__Group_0_0__0"
+ // InternalOXtype.g:9263:1: rule__XShortClosure__Group_0_0__0 : rule__XShortClosure__Group_0_0__0__Impl rule__XShortClosure__Group_0_0__1 ;
+ public final void rule__XShortClosure__Group_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9267:1: ( rule__XShortClosure__Group_0_0__0__Impl rule__XShortClosure__Group_0_0__1 )
+ // InternalOXtype.g:9268:2: rule__XShortClosure__Group_0_0__0__Impl rule__XShortClosure__Group_0_0__1
+ {
+ pushFollow(FOLLOW_59);
+ rule__XShortClosure__Group_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__Group_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group_0_0__0"
+
+
+ // $ANTLR start "rule__XShortClosure__Group_0_0__0__Impl"
+ // InternalOXtype.g:9275:1: rule__XShortClosure__Group_0_0__0__Impl : ( () ) ;
+ public final void rule__XShortClosure__Group_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9279:1: ( ( () ) )
+ // InternalOXtype.g:9280:1: ( () )
+ {
+ // InternalOXtype.g:9280:1: ( () )
+ // InternalOXtype.g:9281:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0());
+ }
+ // InternalOXtype.g:9282:2: ()
+ // InternalOXtype.g:9282:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XShortClosure__Group_0_0__1"
+ // InternalOXtype.g:9290:1: rule__XShortClosure__Group_0_0__1 : rule__XShortClosure__Group_0_0__1__Impl rule__XShortClosure__Group_0_0__2 ;
+ public final void rule__XShortClosure__Group_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9294:1: ( rule__XShortClosure__Group_0_0__1__Impl rule__XShortClosure__Group_0_0__2 )
+ // InternalOXtype.g:9295:2: rule__XShortClosure__Group_0_0__1__Impl rule__XShortClosure__Group_0_0__2
+ {
+ pushFollow(FOLLOW_59);
+ rule__XShortClosure__Group_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__Group_0_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group_0_0__1"
+
+
+ // $ANTLR start "rule__XShortClosure__Group_0_0__1__Impl"
+ // InternalOXtype.g:9302:1: rule__XShortClosure__Group_0_0__1__Impl : ( ( rule__XShortClosure__Group_0_0_1__0 )? ) ;
+ public final void rule__XShortClosure__Group_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9306:1: ( ( ( rule__XShortClosure__Group_0_0_1__0 )? ) )
+ // InternalOXtype.g:9307:1: ( ( rule__XShortClosure__Group_0_0_1__0 )? )
+ {
+ // InternalOXtype.g:9307:1: ( ( rule__XShortClosure__Group_0_0_1__0 )? )
+ // InternalOXtype.g:9308:2: ( rule__XShortClosure__Group_0_0_1__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1());
+ }
+ // InternalOXtype.g:9309:2: ( rule__XShortClosure__Group_0_0_1__0 )?
+ int alt83=2;
+ int LA83_0 = input.LA(1);
+
+ if ( (LA83_0==RULE_ID||LA83_0==31||LA83_0==53) ) {
+ alt83=1;
+ }
+ switch (alt83) {
+ case 1 :
+ // InternalOXtype.g:9309:3: rule__XShortClosure__Group_0_0_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__Group_0_0_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XShortClosure__Group_0_0__2"
+ // InternalOXtype.g:9317:1: rule__XShortClosure__Group_0_0__2 : rule__XShortClosure__Group_0_0__2__Impl ;
+ public final void rule__XShortClosure__Group_0_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9321:1: ( rule__XShortClosure__Group_0_0__2__Impl )
+ // InternalOXtype.g:9322:2: rule__XShortClosure__Group_0_0__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__Group_0_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group_0_0__2"
+
+
+ // $ANTLR start "rule__XShortClosure__Group_0_0__2__Impl"
+ // InternalOXtype.g:9328:1: rule__XShortClosure__Group_0_0__2__Impl : ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) ) ;
+ public final void rule__XShortClosure__Group_0_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9332:1: ( ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) ) )
+ // InternalOXtype.g:9333:1: ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) )
+ {
+ // InternalOXtype.g:9333:1: ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) )
+ // InternalOXtype.g:9334:2: ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2());
+ }
+ // InternalOXtype.g:9335:2: ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 )
+ // InternalOXtype.g:9335:3: rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group_0_0__2__Impl"
+
+
+ // $ANTLR start "rule__XShortClosure__Group_0_0_1__0"
+ // InternalOXtype.g:9344:1: rule__XShortClosure__Group_0_0_1__0 : rule__XShortClosure__Group_0_0_1__0__Impl rule__XShortClosure__Group_0_0_1__1 ;
+ public final void rule__XShortClosure__Group_0_0_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9348:1: ( rule__XShortClosure__Group_0_0_1__0__Impl rule__XShortClosure__Group_0_0_1__1 )
+ // InternalOXtype.g:9349:2: rule__XShortClosure__Group_0_0_1__0__Impl rule__XShortClosure__Group_0_0_1__1
+ {
+ pushFollow(FOLLOW_13);
+ rule__XShortClosure__Group_0_0_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__Group_0_0_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group_0_0_1__0"
+
+
+ // $ANTLR start "rule__XShortClosure__Group_0_0_1__0__Impl"
+ // InternalOXtype.g:9356:1: rule__XShortClosure__Group_0_0_1__0__Impl : ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) ) ;
+ public final void rule__XShortClosure__Group_0_0_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9360:1: ( ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) ) )
+ // InternalOXtype.g:9361:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) )
+ {
+ // InternalOXtype.g:9361:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) )
+ // InternalOXtype.g:9362:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0());
+ }
+ // InternalOXtype.g:9363:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 )
+ // InternalOXtype.g:9363:3: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group_0_0_1__0__Impl"
+
+
+ // $ANTLR start "rule__XShortClosure__Group_0_0_1__1"
+ // InternalOXtype.g:9371:1: rule__XShortClosure__Group_0_0_1__1 : rule__XShortClosure__Group_0_0_1__1__Impl ;
+ public final void rule__XShortClosure__Group_0_0_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9375:1: ( rule__XShortClosure__Group_0_0_1__1__Impl )
+ // InternalOXtype.g:9376:2: rule__XShortClosure__Group_0_0_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__Group_0_0_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group_0_0_1__1"
+
+
+ // $ANTLR start "rule__XShortClosure__Group_0_0_1__1__Impl"
+ // InternalOXtype.g:9382:1: rule__XShortClosure__Group_0_0_1__1__Impl : ( ( rule__XShortClosure__Group_0_0_1_1__0 )* ) ;
+ public final void rule__XShortClosure__Group_0_0_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9386:1: ( ( ( rule__XShortClosure__Group_0_0_1_1__0 )* ) )
+ // InternalOXtype.g:9387:1: ( ( rule__XShortClosure__Group_0_0_1_1__0 )* )
+ {
+ // InternalOXtype.g:9387:1: ( ( rule__XShortClosure__Group_0_0_1_1__0 )* )
+ // InternalOXtype.g:9388:2: ( rule__XShortClosure__Group_0_0_1_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1());
+ }
+ // InternalOXtype.g:9389:2: ( rule__XShortClosure__Group_0_0_1_1__0 )*
+ loop84:
+ do {
+ int alt84=2;
+ int LA84_0 = input.LA(1);
+
+ if ( (LA84_0==55) ) {
+ alt84=1;
+ }
+
+
+ switch (alt84) {
+ case 1 :
+ // InternalOXtype.g:9389:3: rule__XShortClosure__Group_0_0_1_1__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XShortClosure__Group_0_0_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop84;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group_0_0_1__1__Impl"
+
+
+ // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__0"
+ // InternalOXtype.g:9398:1: rule__XShortClosure__Group_0_0_1_1__0 : rule__XShortClosure__Group_0_0_1_1__0__Impl rule__XShortClosure__Group_0_0_1_1__1 ;
+ public final void rule__XShortClosure__Group_0_0_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9402:1: ( rule__XShortClosure__Group_0_0_1_1__0__Impl rule__XShortClosure__Group_0_0_1_1__1 )
+ // InternalOXtype.g:9403:2: rule__XShortClosure__Group_0_0_1_1__0__Impl rule__XShortClosure__Group_0_0_1_1__1
+ {
+ pushFollow(FOLLOW_32);
+ rule__XShortClosure__Group_0_0_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__Group_0_0_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__0"
+
+
+ // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__0__Impl"
+ // InternalOXtype.g:9410:1: rule__XShortClosure__Group_0_0_1_1__0__Impl : ( ',' ) ;
+ public final void rule__XShortClosure__Group_0_0_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9414:1: ( ( ',' ) )
+ // InternalOXtype.g:9415:1: ( ',' )
+ {
+ // InternalOXtype.g:9415:1: ( ',' )
+ // InternalOXtype.g:9416:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__1"
+ // InternalOXtype.g:9425:1: rule__XShortClosure__Group_0_0_1_1__1 : rule__XShortClosure__Group_0_0_1_1__1__Impl ;
+ public final void rule__XShortClosure__Group_0_0_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9429:1: ( rule__XShortClosure__Group_0_0_1_1__1__Impl )
+ // InternalOXtype.g:9430:2: rule__XShortClosure__Group_0_0_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__Group_0_0_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__1"
+
+
+ // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__1__Impl"
+ // InternalOXtype.g:9436:1: rule__XShortClosure__Group_0_0_1_1__1__Impl : ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) ) ;
+ public final void rule__XShortClosure__Group_0_0_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9440:1: ( ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) ) )
+ // InternalOXtype.g:9441:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) )
+ {
+ // InternalOXtype.g:9441:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) )
+ // InternalOXtype.g:9442:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1());
+ }
+ // InternalOXtype.g:9443:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 )
+ // InternalOXtype.g:9443:3: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__XParenthesizedExpression__Group__0"
+ // InternalOXtype.g:9452:1: rule__XParenthesizedExpression__Group__0 : rule__XParenthesizedExpression__Group__0__Impl rule__XParenthesizedExpression__Group__1 ;
+ public final void rule__XParenthesizedExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9456:1: ( rule__XParenthesizedExpression__Group__0__Impl rule__XParenthesizedExpression__Group__1 )
+ // InternalOXtype.g:9457:2: rule__XParenthesizedExpression__Group__0__Impl rule__XParenthesizedExpression__Group__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XParenthesizedExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XParenthesizedExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XParenthesizedExpression__Group__0"
+
+
+ // $ANTLR start "rule__XParenthesizedExpression__Group__0__Impl"
+ // InternalOXtype.g:9464:1: rule__XParenthesizedExpression__Group__0__Impl : ( '(' ) ;
+ public final void rule__XParenthesizedExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9468:1: ( ( '(' ) )
+ // InternalOXtype.g:9469:1: ( '(' )
+ {
+ // InternalOXtype.g:9469:1: ( '(' )
+ // InternalOXtype.g:9470:2: '('
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0());
+ }
+ match(input,53,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XParenthesizedExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XParenthesizedExpression__Group__1"
+ // InternalOXtype.g:9479:1: rule__XParenthesizedExpression__Group__1 : rule__XParenthesizedExpression__Group__1__Impl rule__XParenthesizedExpression__Group__2 ;
+ public final void rule__XParenthesizedExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9483:1: ( rule__XParenthesizedExpression__Group__1__Impl rule__XParenthesizedExpression__Group__2 )
+ // InternalOXtype.g:9484:2: rule__XParenthesizedExpression__Group__1__Impl rule__XParenthesizedExpression__Group__2
+ {
+ pushFollow(FOLLOW_61);
+ rule__XParenthesizedExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XParenthesizedExpression__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XParenthesizedExpression__Group__1"
+
+
+ // $ANTLR start "rule__XParenthesizedExpression__Group__1__Impl"
+ // InternalOXtype.g:9491:1: rule__XParenthesizedExpression__Group__1__Impl : ( ruleXExpression ) ;
+ public final void rule__XParenthesizedExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9495:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:9496:1: ( ruleXExpression )
+ {
+ // InternalOXtype.g:9496:1: ( ruleXExpression )
+ // InternalOXtype.g:9497:2: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XParenthesizedExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XParenthesizedExpression__Group__2"
+ // InternalOXtype.g:9506:1: rule__XParenthesizedExpression__Group__2 : rule__XParenthesizedExpression__Group__2__Impl ;
+ public final void rule__XParenthesizedExpression__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9510:1: ( rule__XParenthesizedExpression__Group__2__Impl )
+ // InternalOXtype.g:9511:2: rule__XParenthesizedExpression__Group__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XParenthesizedExpression__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XParenthesizedExpression__Group__2"
+
+
+ // $ANTLR start "rule__XParenthesizedExpression__Group__2__Impl"
+ // InternalOXtype.g:9517:1: rule__XParenthesizedExpression__Group__2__Impl : ( ')' ) ;
+ public final void rule__XParenthesizedExpression__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9521:1: ( ( ')' ) )
+ // InternalOXtype.g:9522:1: ( ')' )
+ {
+ // InternalOXtype.g:9522:1: ( ')' )
+ // InternalOXtype.g:9523:2: ')'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2());
+ }
+ match(input,54,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XParenthesizedExpression__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XIfExpression__Group__0"
+ // InternalOXtype.g:9533:1: rule__XIfExpression__Group__0 : rule__XIfExpression__Group__0__Impl rule__XIfExpression__Group__1 ;
+ public final void rule__XIfExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9537:1: ( rule__XIfExpression__Group__0__Impl rule__XIfExpression__Group__1 )
+ // InternalOXtype.g:9538:2: rule__XIfExpression__Group__0__Impl rule__XIfExpression__Group__1
+ {
+ pushFollow(FOLLOW_62);
+ rule__XIfExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XIfExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group__0"
+
+
+ // $ANTLR start "rule__XIfExpression__Group__0__Impl"
+ // InternalOXtype.g:9545:1: rule__XIfExpression__Group__0__Impl : ( () ) ;
+ public final void rule__XIfExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9549:1: ( ( () ) )
+ // InternalOXtype.g:9550:1: ( () )
+ {
+ // InternalOXtype.g:9550:1: ( () )
+ // InternalOXtype.g:9551:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0());
+ }
+ // InternalOXtype.g:9552:2: ()
+ // InternalOXtype.g:9552:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XIfExpression__Group__1"
+ // InternalOXtype.g:9560:1: rule__XIfExpression__Group__1 : rule__XIfExpression__Group__1__Impl rule__XIfExpression__Group__2 ;
+ public final void rule__XIfExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9564:1: ( rule__XIfExpression__Group__1__Impl rule__XIfExpression__Group__2 )
+ // InternalOXtype.g:9565:2: rule__XIfExpression__Group__1__Impl rule__XIfExpression__Group__2
+ {
+ pushFollow(FOLLOW_11);
+ rule__XIfExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XIfExpression__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group__1"
+
+
+ // $ANTLR start "rule__XIfExpression__Group__1__Impl"
+ // InternalOXtype.g:9572:1: rule__XIfExpression__Group__1__Impl : ( 'if' ) ;
+ public final void rule__XIfExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9576:1: ( ( 'if' ) )
+ // InternalOXtype.g:9577:1: ( 'if' )
+ {
+ // InternalOXtype.g:9577:1: ( 'if' )
+ // InternalOXtype.g:9578:2: 'if'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXIfExpressionAccess().getIfKeyword_1());
+ }
+ match(input,63,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXIfExpressionAccess().getIfKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XIfExpression__Group__2"
+ // InternalOXtype.g:9587:1: rule__XIfExpression__Group__2 : rule__XIfExpression__Group__2__Impl rule__XIfExpression__Group__3 ;
+ public final void rule__XIfExpression__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9591:1: ( rule__XIfExpression__Group__2__Impl rule__XIfExpression__Group__3 )
+ // InternalOXtype.g:9592:2: rule__XIfExpression__Group__2__Impl rule__XIfExpression__Group__3
+ {
+ pushFollow(FOLLOW_15);
+ rule__XIfExpression__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XIfExpression__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group__2"
+
+
+ // $ANTLR start "rule__XIfExpression__Group__2__Impl"
+ // InternalOXtype.g:9599:1: rule__XIfExpression__Group__2__Impl : ( '(' ) ;
+ public final void rule__XIfExpression__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9603:1: ( ( '(' ) )
+ // InternalOXtype.g:9604:1: ( '(' )
+ {
+ // InternalOXtype.g:9604:1: ( '(' )
+ // InternalOXtype.g:9605:2: '('
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2());
+ }
+ match(input,53,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XIfExpression__Group__3"
+ // InternalOXtype.g:9614:1: rule__XIfExpression__Group__3 : rule__XIfExpression__Group__3__Impl rule__XIfExpression__Group__4 ;
+ public final void rule__XIfExpression__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9618:1: ( rule__XIfExpression__Group__3__Impl rule__XIfExpression__Group__4 )
+ // InternalOXtype.g:9619:2: rule__XIfExpression__Group__3__Impl rule__XIfExpression__Group__4
+ {
+ pushFollow(FOLLOW_61);
+ rule__XIfExpression__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XIfExpression__Group__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group__3"
+
+
+ // $ANTLR start "rule__XIfExpression__Group__3__Impl"
+ // InternalOXtype.g:9626:1: rule__XIfExpression__Group__3__Impl : ( ( rule__XIfExpression__IfAssignment_3 ) ) ;
+ public final void rule__XIfExpression__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9630:1: ( ( ( rule__XIfExpression__IfAssignment_3 ) ) )
+ // InternalOXtype.g:9631:1: ( ( rule__XIfExpression__IfAssignment_3 ) )
+ {
+ // InternalOXtype.g:9631:1: ( ( rule__XIfExpression__IfAssignment_3 ) )
+ // InternalOXtype.g:9632:2: ( rule__XIfExpression__IfAssignment_3 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXIfExpressionAccess().getIfAssignment_3());
+ }
+ // InternalOXtype.g:9633:2: ( rule__XIfExpression__IfAssignment_3 )
+ // InternalOXtype.g:9633:3: rule__XIfExpression__IfAssignment_3
+ {
+ pushFollow(FOLLOW_2);
+ rule__XIfExpression__IfAssignment_3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXIfExpressionAccess().getIfAssignment_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XIfExpression__Group__4"
+ // InternalOXtype.g:9641:1: rule__XIfExpression__Group__4 : rule__XIfExpression__Group__4__Impl rule__XIfExpression__Group__5 ;
+ public final void rule__XIfExpression__Group__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9645:1: ( rule__XIfExpression__Group__4__Impl rule__XIfExpression__Group__5 )
+ // InternalOXtype.g:9646:2: rule__XIfExpression__Group__4__Impl rule__XIfExpression__Group__5
+ {
+ pushFollow(FOLLOW_15);
+ rule__XIfExpression__Group__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XIfExpression__Group__5();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group__4"
+
+
+ // $ANTLR start "rule__XIfExpression__Group__4__Impl"
+ // InternalOXtype.g:9653:1: rule__XIfExpression__Group__4__Impl : ( ')' ) ;
+ public final void rule__XIfExpression__Group__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9657:1: ( ( ')' ) )
+ // InternalOXtype.g:9658:1: ( ')' )
+ {
+ // InternalOXtype.g:9658:1: ( ')' )
+ // InternalOXtype.g:9659:2: ')'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4());
+ }
+ match(input,54,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group__4__Impl"
+
+
+ // $ANTLR start "rule__XIfExpression__Group__5"
+ // InternalOXtype.g:9668:1: rule__XIfExpression__Group__5 : rule__XIfExpression__Group__5__Impl rule__XIfExpression__Group__6 ;
+ public final void rule__XIfExpression__Group__5() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9672:1: ( rule__XIfExpression__Group__5__Impl rule__XIfExpression__Group__6 )
+ // InternalOXtype.g:9673:2: rule__XIfExpression__Group__5__Impl rule__XIfExpression__Group__6
+ {
+ pushFollow(FOLLOW_63);
+ rule__XIfExpression__Group__5__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XIfExpression__Group__6();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group__5"
+
+
+ // $ANTLR start "rule__XIfExpression__Group__5__Impl"
+ // InternalOXtype.g:9680:1: rule__XIfExpression__Group__5__Impl : ( ( rule__XIfExpression__ThenAssignment_5 ) ) ;
+ public final void rule__XIfExpression__Group__5__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9684:1: ( ( ( rule__XIfExpression__ThenAssignment_5 ) ) )
+ // InternalOXtype.g:9685:1: ( ( rule__XIfExpression__ThenAssignment_5 ) )
+ {
+ // InternalOXtype.g:9685:1: ( ( rule__XIfExpression__ThenAssignment_5 ) )
+ // InternalOXtype.g:9686:2: ( rule__XIfExpression__ThenAssignment_5 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXIfExpressionAccess().getThenAssignment_5());
+ }
+ // InternalOXtype.g:9687:2: ( rule__XIfExpression__ThenAssignment_5 )
+ // InternalOXtype.g:9687:3: rule__XIfExpression__ThenAssignment_5
+ {
+ pushFollow(FOLLOW_2);
+ rule__XIfExpression__ThenAssignment_5();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXIfExpressionAccess().getThenAssignment_5());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group__5__Impl"
+
+
+ // $ANTLR start "rule__XIfExpression__Group__6"
+ // InternalOXtype.g:9695:1: rule__XIfExpression__Group__6 : rule__XIfExpression__Group__6__Impl ;
+ public final void rule__XIfExpression__Group__6() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9699:1: ( rule__XIfExpression__Group__6__Impl )
+ // InternalOXtype.g:9700:2: rule__XIfExpression__Group__6__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XIfExpression__Group__6__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group__6"
+
+
+ // $ANTLR start "rule__XIfExpression__Group__6__Impl"
+ // InternalOXtype.g:9706:1: rule__XIfExpression__Group__6__Impl : ( ( rule__XIfExpression__Group_6__0 )? ) ;
+ public final void rule__XIfExpression__Group__6__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9710:1: ( ( ( rule__XIfExpression__Group_6__0 )? ) )
+ // InternalOXtype.g:9711:1: ( ( rule__XIfExpression__Group_6__0 )? )
+ {
+ // InternalOXtype.g:9711:1: ( ( rule__XIfExpression__Group_6__0 )? )
+ // InternalOXtype.g:9712:2: ( rule__XIfExpression__Group_6__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXIfExpressionAccess().getGroup_6());
+ }
+ // InternalOXtype.g:9713:2: ( rule__XIfExpression__Group_6__0 )?
+ int alt85=2;
+ int LA85_0 = input.LA(1);
+
+ if ( (LA85_0==64) ) {
+ int LA85_1 = input.LA(2);
+
+ if ( (synpred129_InternalOXtype()) ) {
+ alt85=1;
+ }
+ }
+ switch (alt85) {
+ case 1 :
+ // InternalOXtype.g:9713:3: rule__XIfExpression__Group_6__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XIfExpression__Group_6__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXIfExpressionAccess().getGroup_6());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group__6__Impl"
+
+
+ // $ANTLR start "rule__XIfExpression__Group_6__0"
+ // InternalOXtype.g:9722:1: rule__XIfExpression__Group_6__0 : rule__XIfExpression__Group_6__0__Impl rule__XIfExpression__Group_6__1 ;
+ public final void rule__XIfExpression__Group_6__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9726:1: ( rule__XIfExpression__Group_6__0__Impl rule__XIfExpression__Group_6__1 )
+ // InternalOXtype.g:9727:2: rule__XIfExpression__Group_6__0__Impl rule__XIfExpression__Group_6__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XIfExpression__Group_6__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XIfExpression__Group_6__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group_6__0"
+
+
+ // $ANTLR start "rule__XIfExpression__Group_6__0__Impl"
+ // InternalOXtype.g:9734:1: rule__XIfExpression__Group_6__0__Impl : ( ( 'else' ) ) ;
+ public final void rule__XIfExpression__Group_6__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9738:1: ( ( ( 'else' ) ) )
+ // InternalOXtype.g:9739:1: ( ( 'else' ) )
+ {
+ // InternalOXtype.g:9739:1: ( ( 'else' ) )
+ // InternalOXtype.g:9740:2: ( 'else' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0());
+ }
+ // InternalOXtype.g:9741:2: ( 'else' )
+ // InternalOXtype.g:9741:3: 'else'
+ {
+ match(input,64,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group_6__0__Impl"
+
+
+ // $ANTLR start "rule__XIfExpression__Group_6__1"
+ // InternalOXtype.g:9749:1: rule__XIfExpression__Group_6__1 : rule__XIfExpression__Group_6__1__Impl ;
+ public final void rule__XIfExpression__Group_6__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9753:1: ( rule__XIfExpression__Group_6__1__Impl )
+ // InternalOXtype.g:9754:2: rule__XIfExpression__Group_6__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XIfExpression__Group_6__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group_6__1"
+
+
+ // $ANTLR start "rule__XIfExpression__Group_6__1__Impl"
+ // InternalOXtype.g:9760:1: rule__XIfExpression__Group_6__1__Impl : ( ( rule__XIfExpression__ElseAssignment_6_1 ) ) ;
+ public final void rule__XIfExpression__Group_6__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9764:1: ( ( ( rule__XIfExpression__ElseAssignment_6_1 ) ) )
+ // InternalOXtype.g:9765:1: ( ( rule__XIfExpression__ElseAssignment_6_1 ) )
+ {
+ // InternalOXtype.g:9765:1: ( ( rule__XIfExpression__ElseAssignment_6_1 ) )
+ // InternalOXtype.g:9766:2: ( rule__XIfExpression__ElseAssignment_6_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1());
+ }
+ // InternalOXtype.g:9767:2: ( rule__XIfExpression__ElseAssignment_6_1 )
+ // InternalOXtype.g:9767:3: rule__XIfExpression__ElseAssignment_6_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XIfExpression__ElseAssignment_6_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__Group_6__1__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group__0"
+ // InternalOXtype.g:9776:1: rule__XSwitchExpression__Group__0 : rule__XSwitchExpression__Group__0__Impl rule__XSwitchExpression__Group__1 ;
+ public final void rule__XSwitchExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9780:1: ( rule__XSwitchExpression__Group__0__Impl rule__XSwitchExpression__Group__1 )
+ // InternalOXtype.g:9781:2: rule__XSwitchExpression__Group__0__Impl rule__XSwitchExpression__Group__1
+ {
+ pushFollow(FOLLOW_64);
+ rule__XSwitchExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group__0"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group__0__Impl"
+ // InternalOXtype.g:9788:1: rule__XSwitchExpression__Group__0__Impl : ( () ) ;
+ public final void rule__XSwitchExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9792:1: ( ( () ) )
+ // InternalOXtype.g:9793:1: ( () )
+ {
+ // InternalOXtype.g:9793:1: ( () )
+ // InternalOXtype.g:9794:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0());
+ }
+ // InternalOXtype.g:9795:2: ()
+ // InternalOXtype.g:9795:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group__1"
+ // InternalOXtype.g:9803:1: rule__XSwitchExpression__Group__1 : rule__XSwitchExpression__Group__1__Impl rule__XSwitchExpression__Group__2 ;
+ public final void rule__XSwitchExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9807:1: ( rule__XSwitchExpression__Group__1__Impl rule__XSwitchExpression__Group__2 )
+ // InternalOXtype.g:9808:2: rule__XSwitchExpression__Group__1__Impl rule__XSwitchExpression__Group__2
+ {
+ pushFollow(FOLLOW_65);
+ rule__XSwitchExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group__1"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group__1__Impl"
+ // InternalOXtype.g:9815:1: rule__XSwitchExpression__Group__1__Impl : ( 'switch' ) ;
+ public final void rule__XSwitchExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9819:1: ( ( 'switch' ) )
+ // InternalOXtype.g:9820:1: ( 'switch' )
+ {
+ // InternalOXtype.g:9820:1: ( 'switch' )
+ // InternalOXtype.g:9821:2: 'switch'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1());
+ }
+ match(input,65,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group__2"
+ // InternalOXtype.g:9830:1: rule__XSwitchExpression__Group__2 : rule__XSwitchExpression__Group__2__Impl rule__XSwitchExpression__Group__3 ;
+ public final void rule__XSwitchExpression__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9834:1: ( rule__XSwitchExpression__Group__2__Impl rule__XSwitchExpression__Group__3 )
+ // InternalOXtype.g:9835:2: rule__XSwitchExpression__Group__2__Impl rule__XSwitchExpression__Group__3
+ {
+ pushFollow(FOLLOW_55);
+ rule__XSwitchExpression__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group__2"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group__2__Impl"
+ // InternalOXtype.g:9842:1: rule__XSwitchExpression__Group__2__Impl : ( ( rule__XSwitchExpression__Alternatives_2 ) ) ;
+ public final void rule__XSwitchExpression__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9846:1: ( ( ( rule__XSwitchExpression__Alternatives_2 ) ) )
+ // InternalOXtype.g:9847:1: ( ( rule__XSwitchExpression__Alternatives_2 ) )
+ {
+ // InternalOXtype.g:9847:1: ( ( rule__XSwitchExpression__Alternatives_2 ) )
+ // InternalOXtype.g:9848:2: ( rule__XSwitchExpression__Alternatives_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2());
+ }
+ // InternalOXtype.g:9849:2: ( rule__XSwitchExpression__Alternatives_2 )
+ // InternalOXtype.g:9849:3: rule__XSwitchExpression__Alternatives_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Alternatives_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group__3"
+ // InternalOXtype.g:9857:1: rule__XSwitchExpression__Group__3 : rule__XSwitchExpression__Group__3__Impl rule__XSwitchExpression__Group__4 ;
+ public final void rule__XSwitchExpression__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9861:1: ( rule__XSwitchExpression__Group__3__Impl rule__XSwitchExpression__Group__4 )
+ // InternalOXtype.g:9862:2: rule__XSwitchExpression__Group__3__Impl rule__XSwitchExpression__Group__4
+ {
+ pushFollow(FOLLOW_66);
+ rule__XSwitchExpression__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group__3"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group__3__Impl"
+ // InternalOXtype.g:9869:1: rule__XSwitchExpression__Group__3__Impl : ( '{' ) ;
+ public final void rule__XSwitchExpression__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9873:1: ( ( '{' ) )
+ // InternalOXtype.g:9874:1: ( '{' )
+ {
+ // InternalOXtype.g:9874:1: ( '{' )
+ // InternalOXtype.g:9875:2: '{'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3());
+ }
+ match(input,61,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group__4"
+ // InternalOXtype.g:9884:1: rule__XSwitchExpression__Group__4 : rule__XSwitchExpression__Group__4__Impl rule__XSwitchExpression__Group__5 ;
+ public final void rule__XSwitchExpression__Group__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9888:1: ( rule__XSwitchExpression__Group__4__Impl rule__XSwitchExpression__Group__5 )
+ // InternalOXtype.g:9889:2: rule__XSwitchExpression__Group__4__Impl rule__XSwitchExpression__Group__5
+ {
+ pushFollow(FOLLOW_66);
+ rule__XSwitchExpression__Group__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group__5();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group__4"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group__4__Impl"
+ // InternalOXtype.g:9896:1: rule__XSwitchExpression__Group__4__Impl : ( ( rule__XSwitchExpression__CasesAssignment_4 )* ) ;
+ public final void rule__XSwitchExpression__Group__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9900:1: ( ( ( rule__XSwitchExpression__CasesAssignment_4 )* ) )
+ // InternalOXtype.g:9901:1: ( ( rule__XSwitchExpression__CasesAssignment_4 )* )
+ {
+ // InternalOXtype.g:9901:1: ( ( rule__XSwitchExpression__CasesAssignment_4 )* )
+ // InternalOXtype.g:9902:2: ( rule__XSwitchExpression__CasesAssignment_4 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4());
+ }
+ // InternalOXtype.g:9903:2: ( rule__XSwitchExpression__CasesAssignment_4 )*
+ loop86:
+ do {
+ int alt86=2;
+ int LA86_0 = input.LA(1);
+
+ if ( (LA86_0==RULE_ID||LA86_0==31||LA86_0==53||LA86_0==55||LA86_0==66||LA86_0==68) ) {
+ alt86=1;
+ }
+
+
+ switch (alt86) {
+ case 1 :
+ // InternalOXtype.g:9903:3: rule__XSwitchExpression__CasesAssignment_4
+ {
+ pushFollow(FOLLOW_67);
+ rule__XSwitchExpression__CasesAssignment_4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop86;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group__4__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group__5"
+ // InternalOXtype.g:9911:1: rule__XSwitchExpression__Group__5 : rule__XSwitchExpression__Group__5__Impl rule__XSwitchExpression__Group__6 ;
+ public final void rule__XSwitchExpression__Group__5() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9915:1: ( rule__XSwitchExpression__Group__5__Impl rule__XSwitchExpression__Group__6 )
+ // InternalOXtype.g:9916:2: rule__XSwitchExpression__Group__5__Impl rule__XSwitchExpression__Group__6
+ {
+ pushFollow(FOLLOW_66);
+ rule__XSwitchExpression__Group__5__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group__6();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group__5"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group__5__Impl"
+ // InternalOXtype.g:9923:1: rule__XSwitchExpression__Group__5__Impl : ( ( rule__XSwitchExpression__Group_5__0 )? ) ;
+ public final void rule__XSwitchExpression__Group__5__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9927:1: ( ( ( rule__XSwitchExpression__Group_5__0 )? ) )
+ // InternalOXtype.g:9928:1: ( ( rule__XSwitchExpression__Group_5__0 )? )
+ {
+ // InternalOXtype.g:9928:1: ( ( rule__XSwitchExpression__Group_5__0 )? )
+ // InternalOXtype.g:9929:2: ( rule__XSwitchExpression__Group_5__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getGroup_5());
+ }
+ // InternalOXtype.g:9930:2: ( rule__XSwitchExpression__Group_5__0 )?
+ int alt87=2;
+ int LA87_0 = input.LA(1);
+
+ if ( (LA87_0==67) ) {
+ alt87=1;
+ }
+ switch (alt87) {
+ case 1 :
+ // InternalOXtype.g:9930:3: rule__XSwitchExpression__Group_5__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_5__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getGroup_5());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group__5__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group__6"
+ // InternalOXtype.g:9938:1: rule__XSwitchExpression__Group__6 : rule__XSwitchExpression__Group__6__Impl ;
+ public final void rule__XSwitchExpression__Group__6() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9942:1: ( rule__XSwitchExpression__Group__6__Impl )
+ // InternalOXtype.g:9943:2: rule__XSwitchExpression__Group__6__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group__6__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group__6"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group__6__Impl"
+ // InternalOXtype.g:9949:1: rule__XSwitchExpression__Group__6__Impl : ( '}' ) ;
+ public final void rule__XSwitchExpression__Group__6__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9953:1: ( ( '}' ) )
+ // InternalOXtype.g:9954:1: ( '}' )
+ {
+ // InternalOXtype.g:9954:1: ( '}' )
+ // InternalOXtype.g:9955:2: '}'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6());
+ }
+ match(input,62,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group__6__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_0__0"
+ // InternalOXtype.g:9965:1: rule__XSwitchExpression__Group_2_0__0 : rule__XSwitchExpression__Group_2_0__0__Impl rule__XSwitchExpression__Group_2_0__1 ;
+ public final void rule__XSwitchExpression__Group_2_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9969:1: ( rule__XSwitchExpression__Group_2_0__0__Impl rule__XSwitchExpression__Group_2_0__1 )
+ // InternalOXtype.g:9970:2: rule__XSwitchExpression__Group_2_0__0__Impl rule__XSwitchExpression__Group_2_0__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XSwitchExpression__Group_2_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_0__0"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_0__0__Impl"
+ // InternalOXtype.g:9977:1: rule__XSwitchExpression__Group_2_0__0__Impl : ( ( rule__XSwitchExpression__Group_2_0_0__0 ) ) ;
+ public final void rule__XSwitchExpression__Group_2_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9981:1: ( ( ( rule__XSwitchExpression__Group_2_0_0__0 ) ) )
+ // InternalOXtype.g:9982:1: ( ( rule__XSwitchExpression__Group_2_0_0__0 ) )
+ {
+ // InternalOXtype.g:9982:1: ( ( rule__XSwitchExpression__Group_2_0_0__0 ) )
+ // InternalOXtype.g:9983:2: ( rule__XSwitchExpression__Group_2_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0());
+ }
+ // InternalOXtype.g:9984:2: ( rule__XSwitchExpression__Group_2_0_0__0 )
+ // InternalOXtype.g:9984:3: rule__XSwitchExpression__Group_2_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_0__0__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_0__1"
+ // InternalOXtype.g:9992:1: rule__XSwitchExpression__Group_2_0__1 : rule__XSwitchExpression__Group_2_0__1__Impl rule__XSwitchExpression__Group_2_0__2 ;
+ public final void rule__XSwitchExpression__Group_2_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:9996:1: ( rule__XSwitchExpression__Group_2_0__1__Impl rule__XSwitchExpression__Group_2_0__2 )
+ // InternalOXtype.g:9997:2: rule__XSwitchExpression__Group_2_0__1__Impl rule__XSwitchExpression__Group_2_0__2
+ {
+ pushFollow(FOLLOW_61);
+ rule__XSwitchExpression__Group_2_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_0__1"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_0__1__Impl"
+ // InternalOXtype.g:10004:1: rule__XSwitchExpression__Group_2_0__1__Impl : ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) ) ;
+ public final void rule__XSwitchExpression__Group_2_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10008:1: ( ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) ) )
+ // InternalOXtype.g:10009:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) )
+ {
+ // InternalOXtype.g:10009:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) )
+ // InternalOXtype.g:10010:2: ( rule__XSwitchExpression__SwitchAssignment_2_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1());
+ }
+ // InternalOXtype.g:10011:2: ( rule__XSwitchExpression__SwitchAssignment_2_0_1 )
+ // InternalOXtype.g:10011:3: rule__XSwitchExpression__SwitchAssignment_2_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__SwitchAssignment_2_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_0__1__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_0__2"
+ // InternalOXtype.g:10019:1: rule__XSwitchExpression__Group_2_0__2 : rule__XSwitchExpression__Group_2_0__2__Impl ;
+ public final void rule__XSwitchExpression__Group_2_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10023:1: ( rule__XSwitchExpression__Group_2_0__2__Impl )
+ // InternalOXtype.g:10024:2: rule__XSwitchExpression__Group_2_0__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_0__2"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_0__2__Impl"
+ // InternalOXtype.g:10030:1: rule__XSwitchExpression__Group_2_0__2__Impl : ( ')' ) ;
+ public final void rule__XSwitchExpression__Group_2_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10034:1: ( ( ')' ) )
+ // InternalOXtype.g:10035:1: ( ')' )
+ {
+ // InternalOXtype.g:10035:1: ( ')' )
+ // InternalOXtype.g:10036:2: ')'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2());
+ }
+ match(input,54,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_0__2__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_0_0__0"
+ // InternalOXtype.g:10046:1: rule__XSwitchExpression__Group_2_0_0__0 : rule__XSwitchExpression__Group_2_0_0__0__Impl ;
+ public final void rule__XSwitchExpression__Group_2_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10050:1: ( rule__XSwitchExpression__Group_2_0_0__0__Impl )
+ // InternalOXtype.g:10051:2: rule__XSwitchExpression__Group_2_0_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_0_0__0"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_0_0__0__Impl"
+ // InternalOXtype.g:10057:1: rule__XSwitchExpression__Group_2_0_0__0__Impl : ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) ) ;
+ public final void rule__XSwitchExpression__Group_2_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10061:1: ( ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) ) )
+ // InternalOXtype.g:10062:1: ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) )
+ {
+ // InternalOXtype.g:10062:1: ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) )
+ // InternalOXtype.g:10063:2: ( rule__XSwitchExpression__Group_2_0_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0());
+ }
+ // InternalOXtype.g:10064:2: ( rule__XSwitchExpression__Group_2_0_0_0__0 )
+ // InternalOXtype.g:10064:3: rule__XSwitchExpression__Group_2_0_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_0_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__0"
+ // InternalOXtype.g:10073:1: rule__XSwitchExpression__Group_2_0_0_0__0 : rule__XSwitchExpression__Group_2_0_0_0__0__Impl rule__XSwitchExpression__Group_2_0_0_0__1 ;
+ public final void rule__XSwitchExpression__Group_2_0_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10077:1: ( rule__XSwitchExpression__Group_2_0_0_0__0__Impl rule__XSwitchExpression__Group_2_0_0_0__1 )
+ // InternalOXtype.g:10078:2: rule__XSwitchExpression__Group_2_0_0_0__0__Impl rule__XSwitchExpression__Group_2_0_0_0__1
+ {
+ pushFollow(FOLLOW_32);
+ rule__XSwitchExpression__Group_2_0_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_0_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__0"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__0__Impl"
+ // InternalOXtype.g:10085:1: rule__XSwitchExpression__Group_2_0_0_0__0__Impl : ( '(' ) ;
+ public final void rule__XSwitchExpression__Group_2_0_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10089:1: ( ( '(' ) )
+ // InternalOXtype.g:10090:1: ( '(' )
+ {
+ // InternalOXtype.g:10090:1: ( '(' )
+ // InternalOXtype.g:10091:2: '('
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0());
+ }
+ match(input,53,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__1"
+ // InternalOXtype.g:10100:1: rule__XSwitchExpression__Group_2_0_0_0__1 : rule__XSwitchExpression__Group_2_0_0_0__1__Impl rule__XSwitchExpression__Group_2_0_0_0__2 ;
+ public final void rule__XSwitchExpression__Group_2_0_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10104:1: ( rule__XSwitchExpression__Group_2_0_0_0__1__Impl rule__XSwitchExpression__Group_2_0_0_0__2 )
+ // InternalOXtype.g:10105:2: rule__XSwitchExpression__Group_2_0_0_0__1__Impl rule__XSwitchExpression__Group_2_0_0_0__2
+ {
+ pushFollow(FOLLOW_68);
+ rule__XSwitchExpression__Group_2_0_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_0_0_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__1"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__1__Impl"
+ // InternalOXtype.g:10112:1: rule__XSwitchExpression__Group_2_0_0_0__1__Impl : ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) ) ;
+ public final void rule__XSwitchExpression__Group_2_0_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10116:1: ( ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) ) )
+ // InternalOXtype.g:10117:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) )
+ {
+ // InternalOXtype.g:10117:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) )
+ // InternalOXtype.g:10118:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1());
+ }
+ // InternalOXtype.g:10119:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 )
+ // InternalOXtype.g:10119:3: rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__2"
+ // InternalOXtype.g:10127:1: rule__XSwitchExpression__Group_2_0_0_0__2 : rule__XSwitchExpression__Group_2_0_0_0__2__Impl ;
+ public final void rule__XSwitchExpression__Group_2_0_0_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10131:1: ( rule__XSwitchExpression__Group_2_0_0_0__2__Impl )
+ // InternalOXtype.g:10132:2: rule__XSwitchExpression__Group_2_0_0_0__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_0_0_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__2"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__2__Impl"
+ // InternalOXtype.g:10138:1: rule__XSwitchExpression__Group_2_0_0_0__2__Impl : ( ':' ) ;
+ public final void rule__XSwitchExpression__Group_2_0_0_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10142:1: ( ( ':' ) )
+ // InternalOXtype.g:10143:1: ( ':' )
+ {
+ // InternalOXtype.g:10143:1: ( ':' )
+ // InternalOXtype.g:10144:2: ':'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2());
+ }
+ match(input,66,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__2__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_1__0"
+ // InternalOXtype.g:10154:1: rule__XSwitchExpression__Group_2_1__0 : rule__XSwitchExpression__Group_2_1__0__Impl rule__XSwitchExpression__Group_2_1__1 ;
+ public final void rule__XSwitchExpression__Group_2_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10158:1: ( rule__XSwitchExpression__Group_2_1__0__Impl rule__XSwitchExpression__Group_2_1__1 )
+ // InternalOXtype.g:10159:2: rule__XSwitchExpression__Group_2_1__0__Impl rule__XSwitchExpression__Group_2_1__1
+ {
+ pushFollow(FOLLOW_65);
+ rule__XSwitchExpression__Group_2_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_1__0"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_1__0__Impl"
+ // InternalOXtype.g:10166:1: rule__XSwitchExpression__Group_2_1__0__Impl : ( ( rule__XSwitchExpression__Group_2_1_0__0 )? ) ;
+ public final void rule__XSwitchExpression__Group_2_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10170:1: ( ( ( rule__XSwitchExpression__Group_2_1_0__0 )? ) )
+ // InternalOXtype.g:10171:1: ( ( rule__XSwitchExpression__Group_2_1_0__0 )? )
+ {
+ // InternalOXtype.g:10171:1: ( ( rule__XSwitchExpression__Group_2_1_0__0 )? )
+ // InternalOXtype.g:10172:2: ( rule__XSwitchExpression__Group_2_1_0__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0());
+ }
+ // InternalOXtype.g:10173:2: ( rule__XSwitchExpression__Group_2_1_0__0 )?
+ int alt88=2;
+ alt88 = dfa88.predict(input);
+ switch (alt88) {
+ case 1 :
+ // InternalOXtype.g:10173:3: rule__XSwitchExpression__Group_2_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_1__0__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_1__1"
+ // InternalOXtype.g:10181:1: rule__XSwitchExpression__Group_2_1__1 : rule__XSwitchExpression__Group_2_1__1__Impl ;
+ public final void rule__XSwitchExpression__Group_2_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10185:1: ( rule__XSwitchExpression__Group_2_1__1__Impl )
+ // InternalOXtype.g:10186:2: rule__XSwitchExpression__Group_2_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_1__1"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_1__1__Impl"
+ // InternalOXtype.g:10192:1: rule__XSwitchExpression__Group_2_1__1__Impl : ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) ) ;
+ public final void rule__XSwitchExpression__Group_2_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10196:1: ( ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) ) )
+ // InternalOXtype.g:10197:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) )
+ {
+ // InternalOXtype.g:10197:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) )
+ // InternalOXtype.g:10198:2: ( rule__XSwitchExpression__SwitchAssignment_2_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1());
+ }
+ // InternalOXtype.g:10199:2: ( rule__XSwitchExpression__SwitchAssignment_2_1_1 )
+ // InternalOXtype.g:10199:3: rule__XSwitchExpression__SwitchAssignment_2_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__SwitchAssignment_2_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_1__1__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_1_0__0"
+ // InternalOXtype.g:10208:1: rule__XSwitchExpression__Group_2_1_0__0 : rule__XSwitchExpression__Group_2_1_0__0__Impl ;
+ public final void rule__XSwitchExpression__Group_2_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10212:1: ( rule__XSwitchExpression__Group_2_1_0__0__Impl )
+ // InternalOXtype.g:10213:2: rule__XSwitchExpression__Group_2_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_1_0__0"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_1_0__0__Impl"
+ // InternalOXtype.g:10219:1: rule__XSwitchExpression__Group_2_1_0__0__Impl : ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) ) ;
+ public final void rule__XSwitchExpression__Group_2_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10223:1: ( ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) ) )
+ // InternalOXtype.g:10224:1: ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) )
+ {
+ // InternalOXtype.g:10224:1: ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) )
+ // InternalOXtype.g:10225:2: ( rule__XSwitchExpression__Group_2_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0());
+ }
+ // InternalOXtype.g:10226:2: ( rule__XSwitchExpression__Group_2_1_0_0__0 )
+ // InternalOXtype.g:10226:3: rule__XSwitchExpression__Group_2_1_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__0"
+ // InternalOXtype.g:10235:1: rule__XSwitchExpression__Group_2_1_0_0__0 : rule__XSwitchExpression__Group_2_1_0_0__0__Impl rule__XSwitchExpression__Group_2_1_0_0__1 ;
+ public final void rule__XSwitchExpression__Group_2_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10239:1: ( rule__XSwitchExpression__Group_2_1_0_0__0__Impl rule__XSwitchExpression__Group_2_1_0_0__1 )
+ // InternalOXtype.g:10240:2: rule__XSwitchExpression__Group_2_1_0_0__0__Impl rule__XSwitchExpression__Group_2_1_0_0__1
+ {
+ pushFollow(FOLLOW_68);
+ rule__XSwitchExpression__Group_2_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__0"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__0__Impl"
+ // InternalOXtype.g:10247:1: rule__XSwitchExpression__Group_2_1_0_0__0__Impl : ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) ) ;
+ public final void rule__XSwitchExpression__Group_2_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10251:1: ( ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) ) )
+ // InternalOXtype.g:10252:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) )
+ {
+ // InternalOXtype.g:10252:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) )
+ // InternalOXtype.g:10253:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0());
+ }
+ // InternalOXtype.g:10254:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 )
+ // InternalOXtype.g:10254:3: rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__1"
+ // InternalOXtype.g:10262:1: rule__XSwitchExpression__Group_2_1_0_0__1 : rule__XSwitchExpression__Group_2_1_0_0__1__Impl ;
+ public final void rule__XSwitchExpression__Group_2_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10266:1: ( rule__XSwitchExpression__Group_2_1_0_0__1__Impl )
+ // InternalOXtype.g:10267:2: rule__XSwitchExpression__Group_2_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__1"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__1__Impl"
+ // InternalOXtype.g:10273:1: rule__XSwitchExpression__Group_2_1_0_0__1__Impl : ( ':' ) ;
+ public final void rule__XSwitchExpression__Group_2_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10277:1: ( ( ':' ) )
+ // InternalOXtype.g:10278:1: ( ':' )
+ {
+ // InternalOXtype.g:10278:1: ( ':' )
+ // InternalOXtype.g:10279:2: ':'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1());
+ }
+ match(input,66,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_5__0"
+ // InternalOXtype.g:10289:1: rule__XSwitchExpression__Group_5__0 : rule__XSwitchExpression__Group_5__0__Impl rule__XSwitchExpression__Group_5__1 ;
+ public final void rule__XSwitchExpression__Group_5__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10293:1: ( rule__XSwitchExpression__Group_5__0__Impl rule__XSwitchExpression__Group_5__1 )
+ // InternalOXtype.g:10294:2: rule__XSwitchExpression__Group_5__0__Impl rule__XSwitchExpression__Group_5__1
+ {
+ pushFollow(FOLLOW_68);
+ rule__XSwitchExpression__Group_5__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_5__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_5__0"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_5__0__Impl"
+ // InternalOXtype.g:10301:1: rule__XSwitchExpression__Group_5__0__Impl : ( 'default' ) ;
+ public final void rule__XSwitchExpression__Group_5__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10305:1: ( ( 'default' ) )
+ // InternalOXtype.g:10306:1: ( 'default' )
+ {
+ // InternalOXtype.g:10306:1: ( 'default' )
+ // InternalOXtype.g:10307:2: 'default'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0());
+ }
+ match(input,67,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_5__0__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_5__1"
+ // InternalOXtype.g:10316:1: rule__XSwitchExpression__Group_5__1 : rule__XSwitchExpression__Group_5__1__Impl rule__XSwitchExpression__Group_5__2 ;
+ public final void rule__XSwitchExpression__Group_5__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10320:1: ( rule__XSwitchExpression__Group_5__1__Impl rule__XSwitchExpression__Group_5__2 )
+ // InternalOXtype.g:10321:2: rule__XSwitchExpression__Group_5__1__Impl rule__XSwitchExpression__Group_5__2
+ {
+ pushFollow(FOLLOW_15);
+ rule__XSwitchExpression__Group_5__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_5__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_5__1"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_5__1__Impl"
+ // InternalOXtype.g:10328:1: rule__XSwitchExpression__Group_5__1__Impl : ( ':' ) ;
+ public final void rule__XSwitchExpression__Group_5__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10332:1: ( ( ':' ) )
+ // InternalOXtype.g:10333:1: ( ':' )
+ {
+ // InternalOXtype.g:10333:1: ( ':' )
+ // InternalOXtype.g:10334:2: ':'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1());
+ }
+ match(input,66,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_5__1__Impl"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_5__2"
+ // InternalOXtype.g:10343:1: rule__XSwitchExpression__Group_5__2 : rule__XSwitchExpression__Group_5__2__Impl ;
+ public final void rule__XSwitchExpression__Group_5__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10347:1: ( rule__XSwitchExpression__Group_5__2__Impl )
+ // InternalOXtype.g:10348:2: rule__XSwitchExpression__Group_5__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_5__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_5__2"
+
+
+ // $ANTLR start "rule__XSwitchExpression__Group_5__2__Impl"
+ // InternalOXtype.g:10354:1: rule__XSwitchExpression__Group_5__2__Impl : ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) ) ;
+ public final void rule__XSwitchExpression__Group_5__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10358:1: ( ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) ) )
+ // InternalOXtype.g:10359:1: ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) )
+ {
+ // InternalOXtype.g:10359:1: ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) )
+ // InternalOXtype.g:10360:2: ( rule__XSwitchExpression__DefaultAssignment_5_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2());
+ }
+ // InternalOXtype.g:10361:2: ( rule__XSwitchExpression__DefaultAssignment_5_2 )
+ // InternalOXtype.g:10361:3: rule__XSwitchExpression__DefaultAssignment_5_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__DefaultAssignment_5_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__Group_5__2__Impl"
+
+
+ // $ANTLR start "rule__XCasePart__Group__0"
+ // InternalOXtype.g:10370:1: rule__XCasePart__Group__0 : rule__XCasePart__Group__0__Impl rule__XCasePart__Group__1 ;
+ public final void rule__XCasePart__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10374:1: ( rule__XCasePart__Group__0__Impl rule__XCasePart__Group__1 )
+ // InternalOXtype.g:10375:2: rule__XCasePart__Group__0__Impl rule__XCasePart__Group__1
+ {
+ pushFollow(FOLLOW_69);
+ rule__XCasePart__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XCasePart__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__Group__0"
+
+
+ // $ANTLR start "rule__XCasePart__Group__0__Impl"
+ // InternalOXtype.g:10382:1: rule__XCasePart__Group__0__Impl : ( () ) ;
+ public final void rule__XCasePart__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10386:1: ( ( () ) )
+ // InternalOXtype.g:10387:1: ( () )
+ {
+ // InternalOXtype.g:10387:1: ( () )
+ // InternalOXtype.g:10388:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCasePartAccess().getXCasePartAction_0());
+ }
+ // InternalOXtype.g:10389:2: ()
+ // InternalOXtype.g:10389:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCasePartAccess().getXCasePartAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XCasePart__Group__1"
+ // InternalOXtype.g:10397:1: rule__XCasePart__Group__1 : rule__XCasePart__Group__1__Impl rule__XCasePart__Group__2 ;
+ public final void rule__XCasePart__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10401:1: ( rule__XCasePart__Group__1__Impl rule__XCasePart__Group__2 )
+ // InternalOXtype.g:10402:2: rule__XCasePart__Group__1__Impl rule__XCasePart__Group__2
+ {
+ pushFollow(FOLLOW_69);
+ rule__XCasePart__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XCasePart__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__Group__1"
+
+
+ // $ANTLR start "rule__XCasePart__Group__1__Impl"
+ // InternalOXtype.g:10409:1: rule__XCasePart__Group__1__Impl : ( ( rule__XCasePart__TypeGuardAssignment_1 )? ) ;
+ public final void rule__XCasePart__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10413:1: ( ( ( rule__XCasePart__TypeGuardAssignment_1 )? ) )
+ // InternalOXtype.g:10414:1: ( ( rule__XCasePart__TypeGuardAssignment_1 )? )
+ {
+ // InternalOXtype.g:10414:1: ( ( rule__XCasePart__TypeGuardAssignment_1 )? )
+ // InternalOXtype.g:10415:2: ( rule__XCasePart__TypeGuardAssignment_1 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1());
+ }
+ // InternalOXtype.g:10416:2: ( rule__XCasePart__TypeGuardAssignment_1 )?
+ int alt89=2;
+ int LA89_0 = input.LA(1);
+
+ if ( (LA89_0==RULE_ID||LA89_0==31||LA89_0==53) ) {
+ alt89=1;
+ }
+ switch (alt89) {
+ case 1 :
+ // InternalOXtype.g:10416:3: rule__XCasePart__TypeGuardAssignment_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCasePart__TypeGuardAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XCasePart__Group__2"
+ // InternalOXtype.g:10424:1: rule__XCasePart__Group__2 : rule__XCasePart__Group__2__Impl rule__XCasePart__Group__3 ;
+ public final void rule__XCasePart__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10428:1: ( rule__XCasePart__Group__2__Impl rule__XCasePart__Group__3 )
+ // InternalOXtype.g:10429:2: rule__XCasePart__Group__2__Impl rule__XCasePart__Group__3
+ {
+ pushFollow(FOLLOW_69);
+ rule__XCasePart__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XCasePart__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__Group__2"
+
+
+ // $ANTLR start "rule__XCasePart__Group__2__Impl"
+ // InternalOXtype.g:10436:1: rule__XCasePart__Group__2__Impl : ( ( rule__XCasePart__Group_2__0 )? ) ;
+ public final void rule__XCasePart__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10440:1: ( ( ( rule__XCasePart__Group_2__0 )? ) )
+ // InternalOXtype.g:10441:1: ( ( rule__XCasePart__Group_2__0 )? )
+ {
+ // InternalOXtype.g:10441:1: ( ( rule__XCasePart__Group_2__0 )? )
+ // InternalOXtype.g:10442:2: ( rule__XCasePart__Group_2__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCasePartAccess().getGroup_2());
+ }
+ // InternalOXtype.g:10443:2: ( rule__XCasePart__Group_2__0 )?
+ int alt90=2;
+ int LA90_0 = input.LA(1);
+
+ if ( (LA90_0==68) ) {
+ alt90=1;
+ }
+ switch (alt90) {
+ case 1 :
+ // InternalOXtype.g:10443:3: rule__XCasePart__Group_2__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCasePart__Group_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCasePartAccess().getGroup_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XCasePart__Group__3"
+ // InternalOXtype.g:10451:1: rule__XCasePart__Group__3 : rule__XCasePart__Group__3__Impl ;
+ public final void rule__XCasePart__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10455:1: ( rule__XCasePart__Group__3__Impl )
+ // InternalOXtype.g:10456:2: rule__XCasePart__Group__3__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCasePart__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__Group__3"
+
+
+ // $ANTLR start "rule__XCasePart__Group__3__Impl"
+ // InternalOXtype.g:10462:1: rule__XCasePart__Group__3__Impl : ( ( rule__XCasePart__Alternatives_3 ) ) ;
+ public final void rule__XCasePart__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10466:1: ( ( ( rule__XCasePart__Alternatives_3 ) ) )
+ // InternalOXtype.g:10467:1: ( ( rule__XCasePart__Alternatives_3 ) )
+ {
+ // InternalOXtype.g:10467:1: ( ( rule__XCasePart__Alternatives_3 ) )
+ // InternalOXtype.g:10468:2: ( rule__XCasePart__Alternatives_3 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCasePartAccess().getAlternatives_3());
+ }
+ // InternalOXtype.g:10469:2: ( rule__XCasePart__Alternatives_3 )
+ // InternalOXtype.g:10469:3: rule__XCasePart__Alternatives_3
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCasePart__Alternatives_3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCasePartAccess().getAlternatives_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XCasePart__Group_2__0"
+ // InternalOXtype.g:10478:1: rule__XCasePart__Group_2__0 : rule__XCasePart__Group_2__0__Impl rule__XCasePart__Group_2__1 ;
+ public final void rule__XCasePart__Group_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10482:1: ( rule__XCasePart__Group_2__0__Impl rule__XCasePart__Group_2__1 )
+ // InternalOXtype.g:10483:2: rule__XCasePart__Group_2__0__Impl rule__XCasePart__Group_2__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XCasePart__Group_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XCasePart__Group_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__Group_2__0"
+
+
+ // $ANTLR start "rule__XCasePart__Group_2__0__Impl"
+ // InternalOXtype.g:10490:1: rule__XCasePart__Group_2__0__Impl : ( 'case' ) ;
+ public final void rule__XCasePart__Group_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10494:1: ( ( 'case' ) )
+ // InternalOXtype.g:10495:1: ( 'case' )
+ {
+ // InternalOXtype.g:10495:1: ( 'case' )
+ // InternalOXtype.g:10496:2: 'case'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0());
+ }
+ match(input,68,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__Group_2__0__Impl"
+
+
+ // $ANTLR start "rule__XCasePart__Group_2__1"
+ // InternalOXtype.g:10505:1: rule__XCasePart__Group_2__1 : rule__XCasePart__Group_2__1__Impl ;
+ public final void rule__XCasePart__Group_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10509:1: ( rule__XCasePart__Group_2__1__Impl )
+ // InternalOXtype.g:10510:2: rule__XCasePart__Group_2__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCasePart__Group_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__Group_2__1"
+
+
+ // $ANTLR start "rule__XCasePart__Group_2__1__Impl"
+ // InternalOXtype.g:10516:1: rule__XCasePart__Group_2__1__Impl : ( ( rule__XCasePart__CaseAssignment_2_1 ) ) ;
+ public final void rule__XCasePart__Group_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10520:1: ( ( ( rule__XCasePart__CaseAssignment_2_1 ) ) )
+ // InternalOXtype.g:10521:1: ( ( rule__XCasePart__CaseAssignment_2_1 ) )
+ {
+ // InternalOXtype.g:10521:1: ( ( rule__XCasePart__CaseAssignment_2_1 ) )
+ // InternalOXtype.g:10522:2: ( rule__XCasePart__CaseAssignment_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1());
+ }
+ // InternalOXtype.g:10523:2: ( rule__XCasePart__CaseAssignment_2_1 )
+ // InternalOXtype.g:10523:3: rule__XCasePart__CaseAssignment_2_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCasePart__CaseAssignment_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__Group_2__1__Impl"
+
+
+ // $ANTLR start "rule__XCasePart__Group_3_0__0"
+ // InternalOXtype.g:10532:1: rule__XCasePart__Group_3_0__0 : rule__XCasePart__Group_3_0__0__Impl rule__XCasePart__Group_3_0__1 ;
+ public final void rule__XCasePart__Group_3_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10536:1: ( rule__XCasePart__Group_3_0__0__Impl rule__XCasePart__Group_3_0__1 )
+ // InternalOXtype.g:10537:2: rule__XCasePart__Group_3_0__0__Impl rule__XCasePart__Group_3_0__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XCasePart__Group_3_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XCasePart__Group_3_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__Group_3_0__0"
+
+
+ // $ANTLR start "rule__XCasePart__Group_3_0__0__Impl"
+ // InternalOXtype.g:10544:1: rule__XCasePart__Group_3_0__0__Impl : ( ':' ) ;
+ public final void rule__XCasePart__Group_3_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10548:1: ( ( ':' ) )
+ // InternalOXtype.g:10549:1: ( ':' )
+ {
+ // InternalOXtype.g:10549:1: ( ':' )
+ // InternalOXtype.g:10550:2: ':'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0());
+ }
+ match(input,66,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__Group_3_0__0__Impl"
+
+
+ // $ANTLR start "rule__XCasePart__Group_3_0__1"
+ // InternalOXtype.g:10559:1: rule__XCasePart__Group_3_0__1 : rule__XCasePart__Group_3_0__1__Impl ;
+ public final void rule__XCasePart__Group_3_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10563:1: ( rule__XCasePart__Group_3_0__1__Impl )
+ // InternalOXtype.g:10564:2: rule__XCasePart__Group_3_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCasePart__Group_3_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__Group_3_0__1"
+
+
+ // $ANTLR start "rule__XCasePart__Group_3_0__1__Impl"
+ // InternalOXtype.g:10570:1: rule__XCasePart__Group_3_0__1__Impl : ( ( rule__XCasePart__ThenAssignment_3_0_1 ) ) ;
+ public final void rule__XCasePart__Group_3_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10574:1: ( ( ( rule__XCasePart__ThenAssignment_3_0_1 ) ) )
+ // InternalOXtype.g:10575:1: ( ( rule__XCasePart__ThenAssignment_3_0_1 ) )
+ {
+ // InternalOXtype.g:10575:1: ( ( rule__XCasePart__ThenAssignment_3_0_1 ) )
+ // InternalOXtype.g:10576:2: ( rule__XCasePart__ThenAssignment_3_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1());
+ }
+ // InternalOXtype.g:10577:2: ( rule__XCasePart__ThenAssignment_3_0_1 )
+ // InternalOXtype.g:10577:3: rule__XCasePart__ThenAssignment_3_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCasePart__ThenAssignment_3_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__Group_3_0__1__Impl"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group__0"
+ // InternalOXtype.g:10586:1: rule__XForLoopExpression__Group__0 : rule__XForLoopExpression__Group__0__Impl rule__XForLoopExpression__Group__1 ;
+ public final void rule__XForLoopExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10590:1: ( rule__XForLoopExpression__Group__0__Impl rule__XForLoopExpression__Group__1 )
+ // InternalOXtype.g:10591:2: rule__XForLoopExpression__Group__0__Impl rule__XForLoopExpression__Group__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XForLoopExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XForLoopExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group__0"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group__0__Impl"
+ // InternalOXtype.g:10598:1: rule__XForLoopExpression__Group__0__Impl : ( ( rule__XForLoopExpression__Group_0__0 ) ) ;
+ public final void rule__XForLoopExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10602:1: ( ( ( rule__XForLoopExpression__Group_0__0 ) ) )
+ // InternalOXtype.g:10603:1: ( ( rule__XForLoopExpression__Group_0__0 ) )
+ {
+ // InternalOXtype.g:10603:1: ( ( rule__XForLoopExpression__Group_0__0 ) )
+ // InternalOXtype.g:10604:2: ( rule__XForLoopExpression__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXForLoopExpressionAccess().getGroup_0());
+ }
+ // InternalOXtype.g:10605:2: ( rule__XForLoopExpression__Group_0__0 )
+ // InternalOXtype.g:10605:3: rule__XForLoopExpression__Group_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XForLoopExpression__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXForLoopExpressionAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group__1"
+ // InternalOXtype.g:10613:1: rule__XForLoopExpression__Group__1 : rule__XForLoopExpression__Group__1__Impl rule__XForLoopExpression__Group__2 ;
+ public final void rule__XForLoopExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10617:1: ( rule__XForLoopExpression__Group__1__Impl rule__XForLoopExpression__Group__2 )
+ // InternalOXtype.g:10618:2: rule__XForLoopExpression__Group__1__Impl rule__XForLoopExpression__Group__2
+ {
+ pushFollow(FOLLOW_61);
+ rule__XForLoopExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XForLoopExpression__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group__1"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group__1__Impl"
+ // InternalOXtype.g:10625:1: rule__XForLoopExpression__Group__1__Impl : ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) ) ;
+ public final void rule__XForLoopExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10629:1: ( ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) ) )
+ // InternalOXtype.g:10630:1: ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) )
+ {
+ // InternalOXtype.g:10630:1: ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) )
+ // InternalOXtype.g:10631:2: ( rule__XForLoopExpression__ForExpressionAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1());
+ }
+ // InternalOXtype.g:10632:2: ( rule__XForLoopExpression__ForExpressionAssignment_1 )
+ // InternalOXtype.g:10632:3: rule__XForLoopExpression__ForExpressionAssignment_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XForLoopExpression__ForExpressionAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group__2"
+ // InternalOXtype.g:10640:1: rule__XForLoopExpression__Group__2 : rule__XForLoopExpression__Group__2__Impl rule__XForLoopExpression__Group__3 ;
+ public final void rule__XForLoopExpression__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10644:1: ( rule__XForLoopExpression__Group__2__Impl rule__XForLoopExpression__Group__3 )
+ // InternalOXtype.g:10645:2: rule__XForLoopExpression__Group__2__Impl rule__XForLoopExpression__Group__3
+ {
+ pushFollow(FOLLOW_15);
+ rule__XForLoopExpression__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XForLoopExpression__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group__2"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group__2__Impl"
+ // InternalOXtype.g:10652:1: rule__XForLoopExpression__Group__2__Impl : ( ')' ) ;
+ public final void rule__XForLoopExpression__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10656:1: ( ( ')' ) )
+ // InternalOXtype.g:10657:1: ( ')' )
+ {
+ // InternalOXtype.g:10657:1: ( ')' )
+ // InternalOXtype.g:10658:2: ')'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2());
+ }
+ match(input,54,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group__3"
+ // InternalOXtype.g:10667:1: rule__XForLoopExpression__Group__3 : rule__XForLoopExpression__Group__3__Impl ;
+ public final void rule__XForLoopExpression__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10671:1: ( rule__XForLoopExpression__Group__3__Impl )
+ // InternalOXtype.g:10672:2: rule__XForLoopExpression__Group__3__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XForLoopExpression__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group__3"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group__3__Impl"
+ // InternalOXtype.g:10678:1: rule__XForLoopExpression__Group__3__Impl : ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) ) ;
+ public final void rule__XForLoopExpression__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10682:1: ( ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) ) )
+ // InternalOXtype.g:10683:1: ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) )
+ {
+ // InternalOXtype.g:10683:1: ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) )
+ // InternalOXtype.g:10684:2: ( rule__XForLoopExpression__EachExpressionAssignment_3 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3());
+ }
+ // InternalOXtype.g:10685:2: ( rule__XForLoopExpression__EachExpressionAssignment_3 )
+ // InternalOXtype.g:10685:3: rule__XForLoopExpression__EachExpressionAssignment_3
+ {
+ pushFollow(FOLLOW_2);
+ rule__XForLoopExpression__EachExpressionAssignment_3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group_0__0"
+ // InternalOXtype.g:10694:1: rule__XForLoopExpression__Group_0__0 : rule__XForLoopExpression__Group_0__0__Impl ;
+ public final void rule__XForLoopExpression__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10698:1: ( rule__XForLoopExpression__Group_0__0__Impl )
+ // InternalOXtype.g:10699:2: rule__XForLoopExpression__Group_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XForLoopExpression__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group_0__0"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group_0__0__Impl"
+ // InternalOXtype.g:10705:1: rule__XForLoopExpression__Group_0__0__Impl : ( ( rule__XForLoopExpression__Group_0_0__0 ) ) ;
+ public final void rule__XForLoopExpression__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10709:1: ( ( ( rule__XForLoopExpression__Group_0_0__0 ) ) )
+ // InternalOXtype.g:10710:1: ( ( rule__XForLoopExpression__Group_0_0__0 ) )
+ {
+ // InternalOXtype.g:10710:1: ( ( rule__XForLoopExpression__Group_0_0__0 ) )
+ // InternalOXtype.g:10711:2: ( rule__XForLoopExpression__Group_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0());
+ }
+ // InternalOXtype.g:10712:2: ( rule__XForLoopExpression__Group_0_0__0 )
+ // InternalOXtype.g:10712:3: rule__XForLoopExpression__Group_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XForLoopExpression__Group_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group_0_0__0"
+ // InternalOXtype.g:10721:1: rule__XForLoopExpression__Group_0_0__0 : rule__XForLoopExpression__Group_0_0__0__Impl rule__XForLoopExpression__Group_0_0__1 ;
+ public final void rule__XForLoopExpression__Group_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10725:1: ( rule__XForLoopExpression__Group_0_0__0__Impl rule__XForLoopExpression__Group_0_0__1 )
+ // InternalOXtype.g:10726:2: rule__XForLoopExpression__Group_0_0__0__Impl rule__XForLoopExpression__Group_0_0__1
+ {
+ pushFollow(FOLLOW_70);
+ rule__XForLoopExpression__Group_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XForLoopExpression__Group_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group_0_0__0"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group_0_0__0__Impl"
+ // InternalOXtype.g:10733:1: rule__XForLoopExpression__Group_0_0__0__Impl : ( () ) ;
+ public final void rule__XForLoopExpression__Group_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10737:1: ( ( () ) )
+ // InternalOXtype.g:10738:1: ( () )
+ {
+ // InternalOXtype.g:10738:1: ( () )
+ // InternalOXtype.g:10739:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0());
+ }
+ // InternalOXtype.g:10740:2: ()
+ // InternalOXtype.g:10740:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group_0_0__1"
+ // InternalOXtype.g:10748:1: rule__XForLoopExpression__Group_0_0__1 : rule__XForLoopExpression__Group_0_0__1__Impl rule__XForLoopExpression__Group_0_0__2 ;
+ public final void rule__XForLoopExpression__Group_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10752:1: ( rule__XForLoopExpression__Group_0_0__1__Impl rule__XForLoopExpression__Group_0_0__2 )
+ // InternalOXtype.g:10753:2: rule__XForLoopExpression__Group_0_0__1__Impl rule__XForLoopExpression__Group_0_0__2
+ {
+ pushFollow(FOLLOW_11);
+ rule__XForLoopExpression__Group_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XForLoopExpression__Group_0_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group_0_0__1"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group_0_0__1__Impl"
+ // InternalOXtype.g:10760:1: rule__XForLoopExpression__Group_0_0__1__Impl : ( 'for' ) ;
+ public final void rule__XForLoopExpression__Group_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10764:1: ( ( 'for' ) )
+ // InternalOXtype.g:10765:1: ( 'for' )
+ {
+ // InternalOXtype.g:10765:1: ( 'for' )
+ // InternalOXtype.g:10766:2: 'for'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1());
+ }
+ match(input,69,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group_0_0__2"
+ // InternalOXtype.g:10775:1: rule__XForLoopExpression__Group_0_0__2 : rule__XForLoopExpression__Group_0_0__2__Impl rule__XForLoopExpression__Group_0_0__3 ;
+ public final void rule__XForLoopExpression__Group_0_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10779:1: ( rule__XForLoopExpression__Group_0_0__2__Impl rule__XForLoopExpression__Group_0_0__3 )
+ // InternalOXtype.g:10780:2: rule__XForLoopExpression__Group_0_0__2__Impl rule__XForLoopExpression__Group_0_0__3
+ {
+ pushFollow(FOLLOW_32);
+ rule__XForLoopExpression__Group_0_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XForLoopExpression__Group_0_0__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group_0_0__2"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group_0_0__2__Impl"
+ // InternalOXtype.g:10787:1: rule__XForLoopExpression__Group_0_0__2__Impl : ( '(' ) ;
+ public final void rule__XForLoopExpression__Group_0_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10791:1: ( ( '(' ) )
+ // InternalOXtype.g:10792:1: ( '(' )
+ {
+ // InternalOXtype.g:10792:1: ( '(' )
+ // InternalOXtype.g:10793:2: '('
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2());
+ }
+ match(input,53,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group_0_0__2__Impl"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group_0_0__3"
+ // InternalOXtype.g:10802:1: rule__XForLoopExpression__Group_0_0__3 : rule__XForLoopExpression__Group_0_0__3__Impl rule__XForLoopExpression__Group_0_0__4 ;
+ public final void rule__XForLoopExpression__Group_0_0__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10806:1: ( rule__XForLoopExpression__Group_0_0__3__Impl rule__XForLoopExpression__Group_0_0__4 )
+ // InternalOXtype.g:10807:2: rule__XForLoopExpression__Group_0_0__3__Impl rule__XForLoopExpression__Group_0_0__4
+ {
+ pushFollow(FOLLOW_68);
+ rule__XForLoopExpression__Group_0_0__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XForLoopExpression__Group_0_0__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group_0_0__3"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group_0_0__3__Impl"
+ // InternalOXtype.g:10814:1: rule__XForLoopExpression__Group_0_0__3__Impl : ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) ) ;
+ public final void rule__XForLoopExpression__Group_0_0__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10818:1: ( ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) ) )
+ // InternalOXtype.g:10819:1: ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) )
+ {
+ // InternalOXtype.g:10819:1: ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) )
+ // InternalOXtype.g:10820:2: ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3());
+ }
+ // InternalOXtype.g:10821:2: ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 )
+ // InternalOXtype.g:10821:3: rule__XForLoopExpression__DeclaredParamAssignment_0_0_3
+ {
+ pushFollow(FOLLOW_2);
+ rule__XForLoopExpression__DeclaredParamAssignment_0_0_3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group_0_0__3__Impl"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group_0_0__4"
+ // InternalOXtype.g:10829:1: rule__XForLoopExpression__Group_0_0__4 : rule__XForLoopExpression__Group_0_0__4__Impl ;
+ public final void rule__XForLoopExpression__Group_0_0__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10833:1: ( rule__XForLoopExpression__Group_0_0__4__Impl )
+ // InternalOXtype.g:10834:2: rule__XForLoopExpression__Group_0_0__4__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XForLoopExpression__Group_0_0__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group_0_0__4"
+
+
+ // $ANTLR start "rule__XForLoopExpression__Group_0_0__4__Impl"
+ // InternalOXtype.g:10840:1: rule__XForLoopExpression__Group_0_0__4__Impl : ( ':' ) ;
+ public final void rule__XForLoopExpression__Group_0_0__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10844:1: ( ( ':' ) )
+ // InternalOXtype.g:10845:1: ( ':' )
+ {
+ // InternalOXtype.g:10845:1: ( ':' )
+ // InternalOXtype.g:10846:2: ':'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4());
+ }
+ match(input,66,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__Group_0_0__4__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__0"
+ // InternalOXtype.g:10856:1: rule__XBasicForLoopExpression__Group__0 : rule__XBasicForLoopExpression__Group__0__Impl rule__XBasicForLoopExpression__Group__1 ;
+ public final void rule__XBasicForLoopExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10860:1: ( rule__XBasicForLoopExpression__Group__0__Impl rule__XBasicForLoopExpression__Group__1 )
+ // InternalOXtype.g:10861:2: rule__XBasicForLoopExpression__Group__0__Impl rule__XBasicForLoopExpression__Group__1
+ {
+ pushFollow(FOLLOW_70);
+ rule__XBasicForLoopExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__0"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__0__Impl"
+ // InternalOXtype.g:10868:1: rule__XBasicForLoopExpression__Group__0__Impl : ( () ) ;
+ public final void rule__XBasicForLoopExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10872:1: ( ( () ) )
+ // InternalOXtype.g:10873:1: ( () )
+ {
+ // InternalOXtype.g:10873:1: ( () )
+ // InternalOXtype.g:10874:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0());
+ }
+ // InternalOXtype.g:10875:2: ()
+ // InternalOXtype.g:10875:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__1"
+ // InternalOXtype.g:10883:1: rule__XBasicForLoopExpression__Group__1 : rule__XBasicForLoopExpression__Group__1__Impl rule__XBasicForLoopExpression__Group__2 ;
+ public final void rule__XBasicForLoopExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10887:1: ( rule__XBasicForLoopExpression__Group__1__Impl rule__XBasicForLoopExpression__Group__2 )
+ // InternalOXtype.g:10888:2: rule__XBasicForLoopExpression__Group__1__Impl rule__XBasicForLoopExpression__Group__2
+ {
+ pushFollow(FOLLOW_11);
+ rule__XBasicForLoopExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__1"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__1__Impl"
+ // InternalOXtype.g:10895:1: rule__XBasicForLoopExpression__Group__1__Impl : ( 'for' ) ;
+ public final void rule__XBasicForLoopExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10899:1: ( ( 'for' ) )
+ // InternalOXtype.g:10900:1: ( 'for' )
+ {
+ // InternalOXtype.g:10900:1: ( 'for' )
+ // InternalOXtype.g:10901:2: 'for'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1());
+ }
+ match(input,69,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__2"
+ // InternalOXtype.g:10910:1: rule__XBasicForLoopExpression__Group__2 : rule__XBasicForLoopExpression__Group__2__Impl rule__XBasicForLoopExpression__Group__3 ;
+ public final void rule__XBasicForLoopExpression__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10914:1: ( rule__XBasicForLoopExpression__Group__2__Impl rule__XBasicForLoopExpression__Group__3 )
+ // InternalOXtype.g:10915:2: rule__XBasicForLoopExpression__Group__2__Impl rule__XBasicForLoopExpression__Group__3
+ {
+ pushFollow(FOLLOW_71);
+ rule__XBasicForLoopExpression__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__2"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__2__Impl"
+ // InternalOXtype.g:10922:1: rule__XBasicForLoopExpression__Group__2__Impl : ( '(' ) ;
+ public final void rule__XBasicForLoopExpression__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10926:1: ( ( '(' ) )
+ // InternalOXtype.g:10927:1: ( '(' )
+ {
+ // InternalOXtype.g:10927:1: ( '(' )
+ // InternalOXtype.g:10928:2: '('
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2());
+ }
+ match(input,53,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__3"
+ // InternalOXtype.g:10937:1: rule__XBasicForLoopExpression__Group__3 : rule__XBasicForLoopExpression__Group__3__Impl rule__XBasicForLoopExpression__Group__4 ;
+ public final void rule__XBasicForLoopExpression__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10941:1: ( rule__XBasicForLoopExpression__Group__3__Impl rule__XBasicForLoopExpression__Group__4 )
+ // InternalOXtype.g:10942:2: rule__XBasicForLoopExpression__Group__3__Impl rule__XBasicForLoopExpression__Group__4
+ {
+ pushFollow(FOLLOW_71);
+ rule__XBasicForLoopExpression__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__3"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__3__Impl"
+ // InternalOXtype.g:10949:1: rule__XBasicForLoopExpression__Group__3__Impl : ( ( rule__XBasicForLoopExpression__Group_3__0 )? ) ;
+ public final void rule__XBasicForLoopExpression__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10953:1: ( ( ( rule__XBasicForLoopExpression__Group_3__0 )? ) )
+ // InternalOXtype.g:10954:1: ( ( rule__XBasicForLoopExpression__Group_3__0 )? )
+ {
+ // InternalOXtype.g:10954:1: ( ( rule__XBasicForLoopExpression__Group_3__0 )? )
+ // InternalOXtype.g:10955:2: ( rule__XBasicForLoopExpression__Group_3__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3());
+ }
+ // InternalOXtype.g:10956:2: ( rule__XBasicForLoopExpression__Group_3__0 )?
+ int alt91=2;
+ int LA91_0 = input.LA(1);
+
+ if ( ((LA91_0>=RULE_ID && LA91_0<=RULE_STRING)||LA91_0==27||(LA91_0>=34 && LA91_0<=35)||LA91_0==40||(LA91_0>=44 && LA91_0<=50)||LA91_0==53||(LA91_0>=57 && LA91_0<=58)||LA91_0==61||LA91_0==63||LA91_0==65||(LA91_0>=69 && LA91_0<=77)||LA91_0==79||(LA91_0>=87 && LA91_0<=88)) ) {
+ alt91=1;
+ }
+ switch (alt91) {
+ case 1 :
+ // InternalOXtype.g:10956:3: rule__XBasicForLoopExpression__Group_3__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__4"
+ // InternalOXtype.g:10964:1: rule__XBasicForLoopExpression__Group__4 : rule__XBasicForLoopExpression__Group__4__Impl rule__XBasicForLoopExpression__Group__5 ;
+ public final void rule__XBasicForLoopExpression__Group__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10968:1: ( rule__XBasicForLoopExpression__Group__4__Impl rule__XBasicForLoopExpression__Group__5 )
+ // InternalOXtype.g:10969:2: rule__XBasicForLoopExpression__Group__4__Impl rule__XBasicForLoopExpression__Group__5
+ {
+ pushFollow(FOLLOW_72);
+ rule__XBasicForLoopExpression__Group__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group__5();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__4"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__4__Impl"
+ // InternalOXtype.g:10976:1: rule__XBasicForLoopExpression__Group__4__Impl : ( ';' ) ;
+ public final void rule__XBasicForLoopExpression__Group__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10980:1: ( ( ';' ) )
+ // InternalOXtype.g:10981:1: ( ';' )
+ {
+ // InternalOXtype.g:10981:1: ( ';' )
+ // InternalOXtype.g:10982:2: ';'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4());
+ }
+ match(input,51,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__4__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__5"
+ // InternalOXtype.g:10991:1: rule__XBasicForLoopExpression__Group__5 : rule__XBasicForLoopExpression__Group__5__Impl rule__XBasicForLoopExpression__Group__6 ;
+ public final void rule__XBasicForLoopExpression__Group__5() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:10995:1: ( rule__XBasicForLoopExpression__Group__5__Impl rule__XBasicForLoopExpression__Group__6 )
+ // InternalOXtype.g:10996:2: rule__XBasicForLoopExpression__Group__5__Impl rule__XBasicForLoopExpression__Group__6
+ {
+ pushFollow(FOLLOW_72);
+ rule__XBasicForLoopExpression__Group__5__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group__6();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__5"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__5__Impl"
+ // InternalOXtype.g:11003:1: rule__XBasicForLoopExpression__Group__5__Impl : ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? ) ;
+ public final void rule__XBasicForLoopExpression__Group__5__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11007:1: ( ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? ) )
+ // InternalOXtype.g:11008:1: ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? )
+ {
+ // InternalOXtype.g:11008:1: ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? )
+ // InternalOXtype.g:11009:2: ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5());
+ }
+ // InternalOXtype.g:11010:2: ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )?
+ int alt92=2;
+ int LA92_0 = input.LA(1);
+
+ if ( ((LA92_0>=RULE_ID && LA92_0<=RULE_STRING)||LA92_0==27||(LA92_0>=34 && LA92_0<=35)||LA92_0==40||(LA92_0>=45 && LA92_0<=50)||LA92_0==53||(LA92_0>=57 && LA92_0<=58)||LA92_0==61||LA92_0==63||LA92_0==65||(LA92_0>=69 && LA92_0<=77)||LA92_0==79||LA92_0==88) ) {
+ alt92=1;
+ }
+ switch (alt92) {
+ case 1 :
+ // InternalOXtype.g:11010:3: rule__XBasicForLoopExpression__ExpressionAssignment_5
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__ExpressionAssignment_5();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__5__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__6"
+ // InternalOXtype.g:11018:1: rule__XBasicForLoopExpression__Group__6 : rule__XBasicForLoopExpression__Group__6__Impl rule__XBasicForLoopExpression__Group__7 ;
+ public final void rule__XBasicForLoopExpression__Group__6() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11022:1: ( rule__XBasicForLoopExpression__Group__6__Impl rule__XBasicForLoopExpression__Group__7 )
+ // InternalOXtype.g:11023:2: rule__XBasicForLoopExpression__Group__6__Impl rule__XBasicForLoopExpression__Group__7
+ {
+ pushFollow(FOLLOW_12);
+ rule__XBasicForLoopExpression__Group__6__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group__7();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__6"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__6__Impl"
+ // InternalOXtype.g:11030:1: rule__XBasicForLoopExpression__Group__6__Impl : ( ';' ) ;
+ public final void rule__XBasicForLoopExpression__Group__6__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11034:1: ( ( ';' ) )
+ // InternalOXtype.g:11035:1: ( ';' )
+ {
+ // InternalOXtype.g:11035:1: ( ';' )
+ // InternalOXtype.g:11036:2: ';'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6());
+ }
+ match(input,51,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__6__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__7"
+ // InternalOXtype.g:11045:1: rule__XBasicForLoopExpression__Group__7 : rule__XBasicForLoopExpression__Group__7__Impl rule__XBasicForLoopExpression__Group__8 ;
+ public final void rule__XBasicForLoopExpression__Group__7() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11049:1: ( rule__XBasicForLoopExpression__Group__7__Impl rule__XBasicForLoopExpression__Group__8 )
+ // InternalOXtype.g:11050:2: rule__XBasicForLoopExpression__Group__7__Impl rule__XBasicForLoopExpression__Group__8
+ {
+ pushFollow(FOLLOW_12);
+ rule__XBasicForLoopExpression__Group__7__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group__8();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__7"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__7__Impl"
+ // InternalOXtype.g:11057:1: rule__XBasicForLoopExpression__Group__7__Impl : ( ( rule__XBasicForLoopExpression__Group_7__0 )? ) ;
+ public final void rule__XBasicForLoopExpression__Group__7__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11061:1: ( ( ( rule__XBasicForLoopExpression__Group_7__0 )? ) )
+ // InternalOXtype.g:11062:1: ( ( rule__XBasicForLoopExpression__Group_7__0 )? )
+ {
+ // InternalOXtype.g:11062:1: ( ( rule__XBasicForLoopExpression__Group_7__0 )? )
+ // InternalOXtype.g:11063:2: ( rule__XBasicForLoopExpression__Group_7__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7());
+ }
+ // InternalOXtype.g:11064:2: ( rule__XBasicForLoopExpression__Group_7__0 )?
+ int alt93=2;
+ int LA93_0 = input.LA(1);
+
+ if ( ((LA93_0>=RULE_ID && LA93_0<=RULE_STRING)||LA93_0==27||(LA93_0>=34 && LA93_0<=35)||LA93_0==40||(LA93_0>=45 && LA93_0<=50)||LA93_0==53||(LA93_0>=57 && LA93_0<=58)||LA93_0==61||LA93_0==63||LA93_0==65||(LA93_0>=69 && LA93_0<=77)||LA93_0==79||LA93_0==88) ) {
+ alt93=1;
+ }
+ switch (alt93) {
+ case 1 :
+ // InternalOXtype.g:11064:3: rule__XBasicForLoopExpression__Group_7__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group_7__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__7__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__8"
+ // InternalOXtype.g:11072:1: rule__XBasicForLoopExpression__Group__8 : rule__XBasicForLoopExpression__Group__8__Impl rule__XBasicForLoopExpression__Group__9 ;
+ public final void rule__XBasicForLoopExpression__Group__8() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11076:1: ( rule__XBasicForLoopExpression__Group__8__Impl rule__XBasicForLoopExpression__Group__9 )
+ // InternalOXtype.g:11077:2: rule__XBasicForLoopExpression__Group__8__Impl rule__XBasicForLoopExpression__Group__9
+ {
+ pushFollow(FOLLOW_15);
+ rule__XBasicForLoopExpression__Group__8__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group__9();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__8"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__8__Impl"
+ // InternalOXtype.g:11084:1: rule__XBasicForLoopExpression__Group__8__Impl : ( ')' ) ;
+ public final void rule__XBasicForLoopExpression__Group__8__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11088:1: ( ( ')' ) )
+ // InternalOXtype.g:11089:1: ( ')' )
+ {
+ // InternalOXtype.g:11089:1: ( ')' )
+ // InternalOXtype.g:11090:2: ')'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8());
+ }
+ match(input,54,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__8__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__9"
+ // InternalOXtype.g:11099:1: rule__XBasicForLoopExpression__Group__9 : rule__XBasicForLoopExpression__Group__9__Impl ;
+ public final void rule__XBasicForLoopExpression__Group__9() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11103:1: ( rule__XBasicForLoopExpression__Group__9__Impl )
+ // InternalOXtype.g:11104:2: rule__XBasicForLoopExpression__Group__9__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group__9__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__9"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group__9__Impl"
+ // InternalOXtype.g:11110:1: rule__XBasicForLoopExpression__Group__9__Impl : ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) ) ;
+ public final void rule__XBasicForLoopExpression__Group__9__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11114:1: ( ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) ) )
+ // InternalOXtype.g:11115:1: ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) )
+ {
+ // InternalOXtype.g:11115:1: ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) )
+ // InternalOXtype.g:11116:2: ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9());
+ }
+ // InternalOXtype.g:11117:2: ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 )
+ // InternalOXtype.g:11117:3: rule__XBasicForLoopExpression__EachExpressionAssignment_9
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__EachExpressionAssignment_9();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group__9__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group_3__0"
+ // InternalOXtype.g:11126:1: rule__XBasicForLoopExpression__Group_3__0 : rule__XBasicForLoopExpression__Group_3__0__Impl rule__XBasicForLoopExpression__Group_3__1 ;
+ public final void rule__XBasicForLoopExpression__Group_3__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11130:1: ( rule__XBasicForLoopExpression__Group_3__0__Impl rule__XBasicForLoopExpression__Group_3__1 )
+ // InternalOXtype.g:11131:2: rule__XBasicForLoopExpression__Group_3__0__Impl rule__XBasicForLoopExpression__Group_3__1
+ {
+ pushFollow(FOLLOW_13);
+ rule__XBasicForLoopExpression__Group_3__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group_3__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group_3__0"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group_3__0__Impl"
+ // InternalOXtype.g:11138:1: rule__XBasicForLoopExpression__Group_3__0__Impl : ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) ) ;
+ public final void rule__XBasicForLoopExpression__Group_3__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11142:1: ( ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) ) )
+ // InternalOXtype.g:11143:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) )
+ {
+ // InternalOXtype.g:11143:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) )
+ // InternalOXtype.g:11144:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0());
+ }
+ // InternalOXtype.g:11145:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 )
+ // InternalOXtype.g:11145:3: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group_3__0__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group_3__1"
+ // InternalOXtype.g:11153:1: rule__XBasicForLoopExpression__Group_3__1 : rule__XBasicForLoopExpression__Group_3__1__Impl ;
+ public final void rule__XBasicForLoopExpression__Group_3__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11157:1: ( rule__XBasicForLoopExpression__Group_3__1__Impl )
+ // InternalOXtype.g:11158:2: rule__XBasicForLoopExpression__Group_3__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group_3__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group_3__1"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group_3__1__Impl"
+ // InternalOXtype.g:11164:1: rule__XBasicForLoopExpression__Group_3__1__Impl : ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* ) ;
+ public final void rule__XBasicForLoopExpression__Group_3__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11168:1: ( ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* ) )
+ // InternalOXtype.g:11169:1: ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* )
+ {
+ // InternalOXtype.g:11169:1: ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* )
+ // InternalOXtype.g:11170:2: ( rule__XBasicForLoopExpression__Group_3_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1());
+ }
+ // InternalOXtype.g:11171:2: ( rule__XBasicForLoopExpression__Group_3_1__0 )*
+ loop94:
+ do {
+ int alt94=2;
+ int LA94_0 = input.LA(1);
+
+ if ( (LA94_0==55) ) {
+ alt94=1;
+ }
+
+
+ switch (alt94) {
+ case 1 :
+ // InternalOXtype.g:11171:3: rule__XBasicForLoopExpression__Group_3_1__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XBasicForLoopExpression__Group_3_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop94;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group_3__1__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__0"
+ // InternalOXtype.g:11180:1: rule__XBasicForLoopExpression__Group_3_1__0 : rule__XBasicForLoopExpression__Group_3_1__0__Impl rule__XBasicForLoopExpression__Group_3_1__1 ;
+ public final void rule__XBasicForLoopExpression__Group_3_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11184:1: ( rule__XBasicForLoopExpression__Group_3_1__0__Impl rule__XBasicForLoopExpression__Group_3_1__1 )
+ // InternalOXtype.g:11185:2: rule__XBasicForLoopExpression__Group_3_1__0__Impl rule__XBasicForLoopExpression__Group_3_1__1
+ {
+ pushFollow(FOLLOW_73);
+ rule__XBasicForLoopExpression__Group_3_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group_3_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__0"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__0__Impl"
+ // InternalOXtype.g:11192:1: rule__XBasicForLoopExpression__Group_3_1__0__Impl : ( ',' ) ;
+ public final void rule__XBasicForLoopExpression__Group_3_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11196:1: ( ( ',' ) )
+ // InternalOXtype.g:11197:1: ( ',' )
+ {
+ // InternalOXtype.g:11197:1: ( ',' )
+ // InternalOXtype.g:11198:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__0__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__1"
+ // InternalOXtype.g:11207:1: rule__XBasicForLoopExpression__Group_3_1__1 : rule__XBasicForLoopExpression__Group_3_1__1__Impl ;
+ public final void rule__XBasicForLoopExpression__Group_3_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11211:1: ( rule__XBasicForLoopExpression__Group_3_1__1__Impl )
+ // InternalOXtype.g:11212:2: rule__XBasicForLoopExpression__Group_3_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group_3_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__1"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__1__Impl"
+ // InternalOXtype.g:11218:1: rule__XBasicForLoopExpression__Group_3_1__1__Impl : ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) ) ;
+ public final void rule__XBasicForLoopExpression__Group_3_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11222:1: ( ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) ) )
+ // InternalOXtype.g:11223:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) )
+ {
+ // InternalOXtype.g:11223:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) )
+ // InternalOXtype.g:11224:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1());
+ }
+ // InternalOXtype.g:11225:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 )
+ // InternalOXtype.g:11225:3: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__1__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group_7__0"
+ // InternalOXtype.g:11234:1: rule__XBasicForLoopExpression__Group_7__0 : rule__XBasicForLoopExpression__Group_7__0__Impl rule__XBasicForLoopExpression__Group_7__1 ;
+ public final void rule__XBasicForLoopExpression__Group_7__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11238:1: ( rule__XBasicForLoopExpression__Group_7__0__Impl rule__XBasicForLoopExpression__Group_7__1 )
+ // InternalOXtype.g:11239:2: rule__XBasicForLoopExpression__Group_7__0__Impl rule__XBasicForLoopExpression__Group_7__1
+ {
+ pushFollow(FOLLOW_13);
+ rule__XBasicForLoopExpression__Group_7__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group_7__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group_7__0"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group_7__0__Impl"
+ // InternalOXtype.g:11246:1: rule__XBasicForLoopExpression__Group_7__0__Impl : ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) ) ;
+ public final void rule__XBasicForLoopExpression__Group_7__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11250:1: ( ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) ) )
+ // InternalOXtype.g:11251:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) )
+ {
+ // InternalOXtype.g:11251:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) )
+ // InternalOXtype.g:11252:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0());
+ }
+ // InternalOXtype.g:11253:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 )
+ // InternalOXtype.g:11253:3: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group_7__0__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group_7__1"
+ // InternalOXtype.g:11261:1: rule__XBasicForLoopExpression__Group_7__1 : rule__XBasicForLoopExpression__Group_7__1__Impl ;
+ public final void rule__XBasicForLoopExpression__Group_7__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11265:1: ( rule__XBasicForLoopExpression__Group_7__1__Impl )
+ // InternalOXtype.g:11266:2: rule__XBasicForLoopExpression__Group_7__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group_7__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group_7__1"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group_7__1__Impl"
+ // InternalOXtype.g:11272:1: rule__XBasicForLoopExpression__Group_7__1__Impl : ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* ) ;
+ public final void rule__XBasicForLoopExpression__Group_7__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11276:1: ( ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* ) )
+ // InternalOXtype.g:11277:1: ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* )
+ {
+ // InternalOXtype.g:11277:1: ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* )
+ // InternalOXtype.g:11278:2: ( rule__XBasicForLoopExpression__Group_7_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1());
+ }
+ // InternalOXtype.g:11279:2: ( rule__XBasicForLoopExpression__Group_7_1__0 )*
+ loop95:
+ do {
+ int alt95=2;
+ int LA95_0 = input.LA(1);
+
+ if ( (LA95_0==55) ) {
+ alt95=1;
+ }
+
+
+ switch (alt95) {
+ case 1 :
+ // InternalOXtype.g:11279:3: rule__XBasicForLoopExpression__Group_7_1__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XBasicForLoopExpression__Group_7_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop95;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group_7__1__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__0"
+ // InternalOXtype.g:11288:1: rule__XBasicForLoopExpression__Group_7_1__0 : rule__XBasicForLoopExpression__Group_7_1__0__Impl rule__XBasicForLoopExpression__Group_7_1__1 ;
+ public final void rule__XBasicForLoopExpression__Group_7_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11292:1: ( rule__XBasicForLoopExpression__Group_7_1__0__Impl rule__XBasicForLoopExpression__Group_7_1__1 )
+ // InternalOXtype.g:11293:2: rule__XBasicForLoopExpression__Group_7_1__0__Impl rule__XBasicForLoopExpression__Group_7_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XBasicForLoopExpression__Group_7_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group_7_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__0"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__0__Impl"
+ // InternalOXtype.g:11300:1: rule__XBasicForLoopExpression__Group_7_1__0__Impl : ( ',' ) ;
+ public final void rule__XBasicForLoopExpression__Group_7_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11304:1: ( ( ',' ) )
+ // InternalOXtype.g:11305:1: ( ',' )
+ {
+ // InternalOXtype.g:11305:1: ( ',' )
+ // InternalOXtype.g:11306:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__0__Impl"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__1"
+ // InternalOXtype.g:11315:1: rule__XBasicForLoopExpression__Group_7_1__1 : rule__XBasicForLoopExpression__Group_7_1__1__Impl ;
+ public final void rule__XBasicForLoopExpression__Group_7_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11319:1: ( rule__XBasicForLoopExpression__Group_7_1__1__Impl )
+ // InternalOXtype.g:11320:2: rule__XBasicForLoopExpression__Group_7_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__Group_7_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__1"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__1__Impl"
+ // InternalOXtype.g:11326:1: rule__XBasicForLoopExpression__Group_7_1__1__Impl : ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) ) ;
+ public final void rule__XBasicForLoopExpression__Group_7_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11330:1: ( ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) ) )
+ // InternalOXtype.g:11331:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) )
+ {
+ // InternalOXtype.g:11331:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) )
+ // InternalOXtype.g:11332:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1());
+ }
+ // InternalOXtype.g:11333:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 )
+ // InternalOXtype.g:11333:3: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__1__Impl"
+
+
+ // $ANTLR start "rule__XWhileExpression__Group__0"
+ // InternalOXtype.g:11342:1: rule__XWhileExpression__Group__0 : rule__XWhileExpression__Group__0__Impl rule__XWhileExpression__Group__1 ;
+ public final void rule__XWhileExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11346:1: ( rule__XWhileExpression__Group__0__Impl rule__XWhileExpression__Group__1 )
+ // InternalOXtype.g:11347:2: rule__XWhileExpression__Group__0__Impl rule__XWhileExpression__Group__1
+ {
+ pushFollow(FOLLOW_74);
+ rule__XWhileExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XWhileExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XWhileExpression__Group__0"
+
+
+ // $ANTLR start "rule__XWhileExpression__Group__0__Impl"
+ // InternalOXtype.g:11354:1: rule__XWhileExpression__Group__0__Impl : ( () ) ;
+ public final void rule__XWhileExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11358:1: ( ( () ) )
+ // InternalOXtype.g:11359:1: ( () )
+ {
+ // InternalOXtype.g:11359:1: ( () )
+ // InternalOXtype.g:11360:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0());
+ }
+ // InternalOXtype.g:11361:2: ()
+ // InternalOXtype.g:11361:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XWhileExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XWhileExpression__Group__1"
+ // InternalOXtype.g:11369:1: rule__XWhileExpression__Group__1 : rule__XWhileExpression__Group__1__Impl rule__XWhileExpression__Group__2 ;
+ public final void rule__XWhileExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11373:1: ( rule__XWhileExpression__Group__1__Impl rule__XWhileExpression__Group__2 )
+ // InternalOXtype.g:11374:2: rule__XWhileExpression__Group__1__Impl rule__XWhileExpression__Group__2
+ {
+ pushFollow(FOLLOW_11);
+ rule__XWhileExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XWhileExpression__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XWhileExpression__Group__1"
+
+
+ // $ANTLR start "rule__XWhileExpression__Group__1__Impl"
+ // InternalOXtype.g:11381:1: rule__XWhileExpression__Group__1__Impl : ( 'while' ) ;
+ public final void rule__XWhileExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11385:1: ( ( 'while' ) )
+ // InternalOXtype.g:11386:1: ( 'while' )
+ {
+ // InternalOXtype.g:11386:1: ( 'while' )
+ // InternalOXtype.g:11387:2: 'while'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1());
+ }
+ match(input,70,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XWhileExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XWhileExpression__Group__2"
+ // InternalOXtype.g:11396:1: rule__XWhileExpression__Group__2 : rule__XWhileExpression__Group__2__Impl rule__XWhileExpression__Group__3 ;
+ public final void rule__XWhileExpression__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11400:1: ( rule__XWhileExpression__Group__2__Impl rule__XWhileExpression__Group__3 )
+ // InternalOXtype.g:11401:2: rule__XWhileExpression__Group__2__Impl rule__XWhileExpression__Group__3
+ {
+ pushFollow(FOLLOW_15);
+ rule__XWhileExpression__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XWhileExpression__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XWhileExpression__Group__2"
+
+
+ // $ANTLR start "rule__XWhileExpression__Group__2__Impl"
+ // InternalOXtype.g:11408:1: rule__XWhileExpression__Group__2__Impl : ( '(' ) ;
+ public final void rule__XWhileExpression__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11412:1: ( ( '(' ) )
+ // InternalOXtype.g:11413:1: ( '(' )
+ {
+ // InternalOXtype.g:11413:1: ( '(' )
+ // InternalOXtype.g:11414:2: '('
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2());
+ }
+ match(input,53,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XWhileExpression__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XWhileExpression__Group__3"
+ // InternalOXtype.g:11423:1: rule__XWhileExpression__Group__3 : rule__XWhileExpression__Group__3__Impl rule__XWhileExpression__Group__4 ;
+ public final void rule__XWhileExpression__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11427:1: ( rule__XWhileExpression__Group__3__Impl rule__XWhileExpression__Group__4 )
+ // InternalOXtype.g:11428:2: rule__XWhileExpression__Group__3__Impl rule__XWhileExpression__Group__4
+ {
+ pushFollow(FOLLOW_61);
+ rule__XWhileExpression__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XWhileExpression__Group__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XWhileExpression__Group__3"
+
+
+ // $ANTLR start "rule__XWhileExpression__Group__3__Impl"
+ // InternalOXtype.g:11435:1: rule__XWhileExpression__Group__3__Impl : ( ( rule__XWhileExpression__PredicateAssignment_3 ) ) ;
+ public final void rule__XWhileExpression__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11439:1: ( ( ( rule__XWhileExpression__PredicateAssignment_3 ) ) )
+ // InternalOXtype.g:11440:1: ( ( rule__XWhileExpression__PredicateAssignment_3 ) )
+ {
+ // InternalOXtype.g:11440:1: ( ( rule__XWhileExpression__PredicateAssignment_3 ) )
+ // InternalOXtype.g:11441:2: ( rule__XWhileExpression__PredicateAssignment_3 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3());
+ }
+ // InternalOXtype.g:11442:2: ( rule__XWhileExpression__PredicateAssignment_3 )
+ // InternalOXtype.g:11442:3: rule__XWhileExpression__PredicateAssignment_3
+ {
+ pushFollow(FOLLOW_2);
+ rule__XWhileExpression__PredicateAssignment_3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XWhileExpression__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XWhileExpression__Group__4"
+ // InternalOXtype.g:11450:1: rule__XWhileExpression__Group__4 : rule__XWhileExpression__Group__4__Impl rule__XWhileExpression__Group__5 ;
+ public final void rule__XWhileExpression__Group__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11454:1: ( rule__XWhileExpression__Group__4__Impl rule__XWhileExpression__Group__5 )
+ // InternalOXtype.g:11455:2: rule__XWhileExpression__Group__4__Impl rule__XWhileExpression__Group__5
+ {
+ pushFollow(FOLLOW_15);
+ rule__XWhileExpression__Group__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XWhileExpression__Group__5();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XWhileExpression__Group__4"
+
+
+ // $ANTLR start "rule__XWhileExpression__Group__4__Impl"
+ // InternalOXtype.g:11462:1: rule__XWhileExpression__Group__4__Impl : ( ')' ) ;
+ public final void rule__XWhileExpression__Group__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11466:1: ( ( ')' ) )
+ // InternalOXtype.g:11467:1: ( ')' )
+ {
+ // InternalOXtype.g:11467:1: ( ')' )
+ // InternalOXtype.g:11468:2: ')'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4());
+ }
+ match(input,54,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XWhileExpression__Group__4__Impl"
+
+
+ // $ANTLR start "rule__XWhileExpression__Group__5"
+ // InternalOXtype.g:11477:1: rule__XWhileExpression__Group__5 : rule__XWhileExpression__Group__5__Impl ;
+ public final void rule__XWhileExpression__Group__5() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11481:1: ( rule__XWhileExpression__Group__5__Impl )
+ // InternalOXtype.g:11482:2: rule__XWhileExpression__Group__5__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XWhileExpression__Group__5__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XWhileExpression__Group__5"
+
+
+ // $ANTLR start "rule__XWhileExpression__Group__5__Impl"
+ // InternalOXtype.g:11488:1: rule__XWhileExpression__Group__5__Impl : ( ( rule__XWhileExpression__BodyAssignment_5 ) ) ;
+ public final void rule__XWhileExpression__Group__5__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11492:1: ( ( ( rule__XWhileExpression__BodyAssignment_5 ) ) )
+ // InternalOXtype.g:11493:1: ( ( rule__XWhileExpression__BodyAssignment_5 ) )
+ {
+ // InternalOXtype.g:11493:1: ( ( rule__XWhileExpression__BodyAssignment_5 ) )
+ // InternalOXtype.g:11494:2: ( rule__XWhileExpression__BodyAssignment_5 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5());
+ }
+ // InternalOXtype.g:11495:2: ( rule__XWhileExpression__BodyAssignment_5 )
+ // InternalOXtype.g:11495:3: rule__XWhileExpression__BodyAssignment_5
+ {
+ pushFollow(FOLLOW_2);
+ rule__XWhileExpression__BodyAssignment_5();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XWhileExpression__Group__5__Impl"
+
+
+ // $ANTLR start "rule__XDoWhileExpression__Group__0"
+ // InternalOXtype.g:11504:1: rule__XDoWhileExpression__Group__0 : rule__XDoWhileExpression__Group__0__Impl rule__XDoWhileExpression__Group__1 ;
+ public final void rule__XDoWhileExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11508:1: ( rule__XDoWhileExpression__Group__0__Impl rule__XDoWhileExpression__Group__1 )
+ // InternalOXtype.g:11509:2: rule__XDoWhileExpression__Group__0__Impl rule__XDoWhileExpression__Group__1
+ {
+ pushFollow(FOLLOW_75);
+ rule__XDoWhileExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XDoWhileExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XDoWhileExpression__Group__0"
+
+
+ // $ANTLR start "rule__XDoWhileExpression__Group__0__Impl"
+ // InternalOXtype.g:11516:1: rule__XDoWhileExpression__Group__0__Impl : ( () ) ;
+ public final void rule__XDoWhileExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11520:1: ( ( () ) )
+ // InternalOXtype.g:11521:1: ( () )
+ {
+ // InternalOXtype.g:11521:1: ( () )
+ // InternalOXtype.g:11522:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0());
+ }
+ // InternalOXtype.g:11523:2: ()
+ // InternalOXtype.g:11523:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XDoWhileExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XDoWhileExpression__Group__1"
+ // InternalOXtype.g:11531:1: rule__XDoWhileExpression__Group__1 : rule__XDoWhileExpression__Group__1__Impl rule__XDoWhileExpression__Group__2 ;
+ public final void rule__XDoWhileExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11535:1: ( rule__XDoWhileExpression__Group__1__Impl rule__XDoWhileExpression__Group__2 )
+ // InternalOXtype.g:11536:2: rule__XDoWhileExpression__Group__1__Impl rule__XDoWhileExpression__Group__2
+ {
+ pushFollow(FOLLOW_15);
+ rule__XDoWhileExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XDoWhileExpression__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XDoWhileExpression__Group__1"
+
+
+ // $ANTLR start "rule__XDoWhileExpression__Group__1__Impl"
+ // InternalOXtype.g:11543:1: rule__XDoWhileExpression__Group__1__Impl : ( 'do' ) ;
+ public final void rule__XDoWhileExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11547:1: ( ( 'do' ) )
+ // InternalOXtype.g:11548:1: ( 'do' )
+ {
+ // InternalOXtype.g:11548:1: ( 'do' )
+ // InternalOXtype.g:11549:2: 'do'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1());
+ }
+ match(input,71,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XDoWhileExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XDoWhileExpression__Group__2"
+ // InternalOXtype.g:11558:1: rule__XDoWhileExpression__Group__2 : rule__XDoWhileExpression__Group__2__Impl rule__XDoWhileExpression__Group__3 ;
+ public final void rule__XDoWhileExpression__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11562:1: ( rule__XDoWhileExpression__Group__2__Impl rule__XDoWhileExpression__Group__3 )
+ // InternalOXtype.g:11563:2: rule__XDoWhileExpression__Group__2__Impl rule__XDoWhileExpression__Group__3
+ {
+ pushFollow(FOLLOW_74);
+ rule__XDoWhileExpression__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XDoWhileExpression__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XDoWhileExpression__Group__2"
+
+
+ // $ANTLR start "rule__XDoWhileExpression__Group__2__Impl"
+ // InternalOXtype.g:11570:1: rule__XDoWhileExpression__Group__2__Impl : ( ( rule__XDoWhileExpression__BodyAssignment_2 ) ) ;
+ public final void rule__XDoWhileExpression__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11574:1: ( ( ( rule__XDoWhileExpression__BodyAssignment_2 ) ) )
+ // InternalOXtype.g:11575:1: ( ( rule__XDoWhileExpression__BodyAssignment_2 ) )
+ {
+ // InternalOXtype.g:11575:1: ( ( rule__XDoWhileExpression__BodyAssignment_2 ) )
+ // InternalOXtype.g:11576:2: ( rule__XDoWhileExpression__BodyAssignment_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2());
+ }
+ // InternalOXtype.g:11577:2: ( rule__XDoWhileExpression__BodyAssignment_2 )
+ // InternalOXtype.g:11577:3: rule__XDoWhileExpression__BodyAssignment_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XDoWhileExpression__BodyAssignment_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XDoWhileExpression__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XDoWhileExpression__Group__3"
+ // InternalOXtype.g:11585:1: rule__XDoWhileExpression__Group__3 : rule__XDoWhileExpression__Group__3__Impl rule__XDoWhileExpression__Group__4 ;
+ public final void rule__XDoWhileExpression__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11589:1: ( rule__XDoWhileExpression__Group__3__Impl rule__XDoWhileExpression__Group__4 )
+ // InternalOXtype.g:11590:2: rule__XDoWhileExpression__Group__3__Impl rule__XDoWhileExpression__Group__4
+ {
+ pushFollow(FOLLOW_11);
+ rule__XDoWhileExpression__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XDoWhileExpression__Group__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XDoWhileExpression__Group__3"
+
+
+ // $ANTLR start "rule__XDoWhileExpression__Group__3__Impl"
+ // InternalOXtype.g:11597:1: rule__XDoWhileExpression__Group__3__Impl : ( 'while' ) ;
+ public final void rule__XDoWhileExpression__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11601:1: ( ( 'while' ) )
+ // InternalOXtype.g:11602:1: ( 'while' )
+ {
+ // InternalOXtype.g:11602:1: ( 'while' )
+ // InternalOXtype.g:11603:2: 'while'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3());
+ }
+ match(input,70,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XDoWhileExpression__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XDoWhileExpression__Group__4"
+ // InternalOXtype.g:11612:1: rule__XDoWhileExpression__Group__4 : rule__XDoWhileExpression__Group__4__Impl rule__XDoWhileExpression__Group__5 ;
+ public final void rule__XDoWhileExpression__Group__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11616:1: ( rule__XDoWhileExpression__Group__4__Impl rule__XDoWhileExpression__Group__5 )
+ // InternalOXtype.g:11617:2: rule__XDoWhileExpression__Group__4__Impl rule__XDoWhileExpression__Group__5
+ {
+ pushFollow(FOLLOW_15);
+ rule__XDoWhileExpression__Group__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XDoWhileExpression__Group__5();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XDoWhileExpression__Group__4"
+
+
+ // $ANTLR start "rule__XDoWhileExpression__Group__4__Impl"
+ // InternalOXtype.g:11624:1: rule__XDoWhileExpression__Group__4__Impl : ( '(' ) ;
+ public final void rule__XDoWhileExpression__Group__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11628:1: ( ( '(' ) )
+ // InternalOXtype.g:11629:1: ( '(' )
+ {
+ // InternalOXtype.g:11629:1: ( '(' )
+ // InternalOXtype.g:11630:2: '('
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4());
+ }
+ match(input,53,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XDoWhileExpression__Group__4__Impl"
+
+
+ // $ANTLR start "rule__XDoWhileExpression__Group__5"
+ // InternalOXtype.g:11639:1: rule__XDoWhileExpression__Group__5 : rule__XDoWhileExpression__Group__5__Impl rule__XDoWhileExpression__Group__6 ;
+ public final void rule__XDoWhileExpression__Group__5() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11643:1: ( rule__XDoWhileExpression__Group__5__Impl rule__XDoWhileExpression__Group__6 )
+ // InternalOXtype.g:11644:2: rule__XDoWhileExpression__Group__5__Impl rule__XDoWhileExpression__Group__6
+ {
+ pushFollow(FOLLOW_61);
+ rule__XDoWhileExpression__Group__5__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XDoWhileExpression__Group__6();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XDoWhileExpression__Group__5"
+
+
+ // $ANTLR start "rule__XDoWhileExpression__Group__5__Impl"
+ // InternalOXtype.g:11651:1: rule__XDoWhileExpression__Group__5__Impl : ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) ) ;
+ public final void rule__XDoWhileExpression__Group__5__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11655:1: ( ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) ) )
+ // InternalOXtype.g:11656:1: ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) )
+ {
+ // InternalOXtype.g:11656:1: ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) )
+ // InternalOXtype.g:11657:2: ( rule__XDoWhileExpression__PredicateAssignment_5 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5());
+ }
+ // InternalOXtype.g:11658:2: ( rule__XDoWhileExpression__PredicateAssignment_5 )
+ // InternalOXtype.g:11658:3: rule__XDoWhileExpression__PredicateAssignment_5
+ {
+ pushFollow(FOLLOW_2);
+ rule__XDoWhileExpression__PredicateAssignment_5();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XDoWhileExpression__Group__5__Impl"
+
+
+ // $ANTLR start "rule__XDoWhileExpression__Group__6"
+ // InternalOXtype.g:11666:1: rule__XDoWhileExpression__Group__6 : rule__XDoWhileExpression__Group__6__Impl ;
+ public final void rule__XDoWhileExpression__Group__6() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11670:1: ( rule__XDoWhileExpression__Group__6__Impl )
+ // InternalOXtype.g:11671:2: rule__XDoWhileExpression__Group__6__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XDoWhileExpression__Group__6__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XDoWhileExpression__Group__6"
+
+
+ // $ANTLR start "rule__XDoWhileExpression__Group__6__Impl"
+ // InternalOXtype.g:11677:1: rule__XDoWhileExpression__Group__6__Impl : ( ')' ) ;
+ public final void rule__XDoWhileExpression__Group__6__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11681:1: ( ( ')' ) )
+ // InternalOXtype.g:11682:1: ( ')' )
+ {
+ // InternalOXtype.g:11682:1: ( ')' )
+ // InternalOXtype.g:11683:2: ')'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6());
+ }
+ match(input,54,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XDoWhileExpression__Group__6__Impl"
+
+
+ // $ANTLR start "rule__XBlockExpression__Group__0"
+ // InternalOXtype.g:11693:1: rule__XBlockExpression__Group__0 : rule__XBlockExpression__Group__0__Impl rule__XBlockExpression__Group__1 ;
+ public final void rule__XBlockExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11697:1: ( rule__XBlockExpression__Group__0__Impl rule__XBlockExpression__Group__1 )
+ // InternalOXtype.g:11698:2: rule__XBlockExpression__Group__0__Impl rule__XBlockExpression__Group__1
+ {
+ pushFollow(FOLLOW_55);
+ rule__XBlockExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBlockExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBlockExpression__Group__0"
+
+
+ // $ANTLR start "rule__XBlockExpression__Group__0__Impl"
+ // InternalOXtype.g:11705:1: rule__XBlockExpression__Group__0__Impl : ( () ) ;
+ public final void rule__XBlockExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11709:1: ( ( () ) )
+ // InternalOXtype.g:11710:1: ( () )
+ {
+ // InternalOXtype.g:11710:1: ( () )
+ // InternalOXtype.g:11711:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0());
+ }
+ // InternalOXtype.g:11712:2: ()
+ // InternalOXtype.g:11712:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBlockExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XBlockExpression__Group__1"
+ // InternalOXtype.g:11720:1: rule__XBlockExpression__Group__1 : rule__XBlockExpression__Group__1__Impl rule__XBlockExpression__Group__2 ;
+ public final void rule__XBlockExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11724:1: ( rule__XBlockExpression__Group__1__Impl rule__XBlockExpression__Group__2 )
+ // InternalOXtype.g:11725:2: rule__XBlockExpression__Group__1__Impl rule__XBlockExpression__Group__2
+ {
+ pushFollow(FOLLOW_76);
+ rule__XBlockExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBlockExpression__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBlockExpression__Group__1"
+
+
+ // $ANTLR start "rule__XBlockExpression__Group__1__Impl"
+ // InternalOXtype.g:11732:1: rule__XBlockExpression__Group__1__Impl : ( '{' ) ;
+ public final void rule__XBlockExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11736:1: ( ( '{' ) )
+ // InternalOXtype.g:11737:1: ( '{' )
+ {
+ // InternalOXtype.g:11737:1: ( '{' )
+ // InternalOXtype.g:11738:2: '{'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1());
+ }
+ match(input,61,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBlockExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XBlockExpression__Group__2"
+ // InternalOXtype.g:11747:1: rule__XBlockExpression__Group__2 : rule__XBlockExpression__Group__2__Impl rule__XBlockExpression__Group__3 ;
+ public final void rule__XBlockExpression__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11751:1: ( rule__XBlockExpression__Group__2__Impl rule__XBlockExpression__Group__3 )
+ // InternalOXtype.g:11752:2: rule__XBlockExpression__Group__2__Impl rule__XBlockExpression__Group__3
+ {
+ pushFollow(FOLLOW_76);
+ rule__XBlockExpression__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBlockExpression__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBlockExpression__Group__2"
+
+
+ // $ANTLR start "rule__XBlockExpression__Group__2__Impl"
+ // InternalOXtype.g:11759:1: rule__XBlockExpression__Group__2__Impl : ( ( rule__XBlockExpression__Group_2__0 )* ) ;
+ public final void rule__XBlockExpression__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11763:1: ( ( ( rule__XBlockExpression__Group_2__0 )* ) )
+ // InternalOXtype.g:11764:1: ( ( rule__XBlockExpression__Group_2__0 )* )
+ {
+ // InternalOXtype.g:11764:1: ( ( rule__XBlockExpression__Group_2__0 )* )
+ // InternalOXtype.g:11765:2: ( rule__XBlockExpression__Group_2__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBlockExpressionAccess().getGroup_2());
+ }
+ // InternalOXtype.g:11766:2: ( rule__XBlockExpression__Group_2__0 )*
+ loop96:
+ do {
+ int alt96=2;
+ int LA96_0 = input.LA(1);
+
+ if ( ((LA96_0>=RULE_ID && LA96_0<=RULE_STRING)||LA96_0==27||(LA96_0>=34 && LA96_0<=35)||LA96_0==40||(LA96_0>=44 && LA96_0<=50)||LA96_0==53||(LA96_0>=57 && LA96_0<=58)||LA96_0==61||LA96_0==63||LA96_0==65||(LA96_0>=69 && LA96_0<=77)||LA96_0==79||(LA96_0>=87 && LA96_0<=88)) ) {
+ alt96=1;
+ }
+
+
+ switch (alt96) {
+ case 1 :
+ // InternalOXtype.g:11766:3: rule__XBlockExpression__Group_2__0
+ {
+ pushFollow(FOLLOW_60);
+ rule__XBlockExpression__Group_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop96;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBlockExpressionAccess().getGroup_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBlockExpression__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XBlockExpression__Group__3"
+ // InternalOXtype.g:11774:1: rule__XBlockExpression__Group__3 : rule__XBlockExpression__Group__3__Impl ;
+ public final void rule__XBlockExpression__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11778:1: ( rule__XBlockExpression__Group__3__Impl )
+ // InternalOXtype.g:11779:2: rule__XBlockExpression__Group__3__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBlockExpression__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBlockExpression__Group__3"
+
+
+ // $ANTLR start "rule__XBlockExpression__Group__3__Impl"
+ // InternalOXtype.g:11785:1: rule__XBlockExpression__Group__3__Impl : ( '}' ) ;
+ public final void rule__XBlockExpression__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11789:1: ( ( '}' ) )
+ // InternalOXtype.g:11790:1: ( '}' )
+ {
+ // InternalOXtype.g:11790:1: ( '}' )
+ // InternalOXtype.g:11791:2: '}'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3());
+ }
+ match(input,62,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBlockExpression__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XBlockExpression__Group_2__0"
+ // InternalOXtype.g:11801:1: rule__XBlockExpression__Group_2__0 : rule__XBlockExpression__Group_2__0__Impl rule__XBlockExpression__Group_2__1 ;
+ public final void rule__XBlockExpression__Group_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11805:1: ( rule__XBlockExpression__Group_2__0__Impl rule__XBlockExpression__Group_2__1 )
+ // InternalOXtype.g:11806:2: rule__XBlockExpression__Group_2__0__Impl rule__XBlockExpression__Group_2__1
+ {
+ pushFollow(FOLLOW_6);
+ rule__XBlockExpression__Group_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBlockExpression__Group_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBlockExpression__Group_2__0"
+
+
+ // $ANTLR start "rule__XBlockExpression__Group_2__0__Impl"
+ // InternalOXtype.g:11813:1: rule__XBlockExpression__Group_2__0__Impl : ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) ) ;
+ public final void rule__XBlockExpression__Group_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11817:1: ( ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) ) )
+ // InternalOXtype.g:11818:1: ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) )
+ {
+ // InternalOXtype.g:11818:1: ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) )
+ // InternalOXtype.g:11819:2: ( rule__XBlockExpression__ExpressionsAssignment_2_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0());
+ }
+ // InternalOXtype.g:11820:2: ( rule__XBlockExpression__ExpressionsAssignment_2_0 )
+ // InternalOXtype.g:11820:3: rule__XBlockExpression__ExpressionsAssignment_2_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBlockExpression__ExpressionsAssignment_2_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBlockExpression__Group_2__0__Impl"
+
+
+ // $ANTLR start "rule__XBlockExpression__Group_2__1"
+ // InternalOXtype.g:11828:1: rule__XBlockExpression__Group_2__1 : rule__XBlockExpression__Group_2__1__Impl ;
+ public final void rule__XBlockExpression__Group_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11832:1: ( rule__XBlockExpression__Group_2__1__Impl )
+ // InternalOXtype.g:11833:2: rule__XBlockExpression__Group_2__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBlockExpression__Group_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBlockExpression__Group_2__1"
+
+
+ // $ANTLR start "rule__XBlockExpression__Group_2__1__Impl"
+ // InternalOXtype.g:11839:1: rule__XBlockExpression__Group_2__1__Impl : ( ( ';' )? ) ;
+ public final void rule__XBlockExpression__Group_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11843:1: ( ( ( ';' )? ) )
+ // InternalOXtype.g:11844:1: ( ( ';' )? )
+ {
+ // InternalOXtype.g:11844:1: ( ( ';' )? )
+ // InternalOXtype.g:11845:2: ( ';' )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1());
+ }
+ // InternalOXtype.g:11846:2: ( ';' )?
+ int alt97=2;
+ int LA97_0 = input.LA(1);
+
+ if ( (LA97_0==51) ) {
+ alt97=1;
+ }
+ switch (alt97) {
+ case 1 :
+ // InternalOXtype.g:11846:3: ';'
+ {
+ match(input,51,FOLLOW_2); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBlockExpression__Group_2__1__Impl"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group__0"
+ // InternalOXtype.g:11855:1: rule__XVariableDeclaration__Group__0 : rule__XVariableDeclaration__Group__0__Impl rule__XVariableDeclaration__Group__1 ;
+ public final void rule__XVariableDeclaration__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11859:1: ( rule__XVariableDeclaration__Group__0__Impl rule__XVariableDeclaration__Group__1 )
+ // InternalOXtype.g:11860:2: rule__XVariableDeclaration__Group__0__Impl rule__XVariableDeclaration__Group__1
+ {
+ pushFollow(FOLLOW_77);
+ rule__XVariableDeclaration__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group__0"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group__0__Impl"
+ // InternalOXtype.g:11867:1: rule__XVariableDeclaration__Group__0__Impl : ( () ) ;
+ public final void rule__XVariableDeclaration__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11871:1: ( ( () ) )
+ // InternalOXtype.g:11872:1: ( () )
+ {
+ // InternalOXtype.g:11872:1: ( () )
+ // InternalOXtype.g:11873:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0());
+ }
+ // InternalOXtype.g:11874:2: ()
+ // InternalOXtype.g:11874:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group__1"
+ // InternalOXtype.g:11882:1: rule__XVariableDeclaration__Group__1 : rule__XVariableDeclaration__Group__1__Impl rule__XVariableDeclaration__Group__2 ;
+ public final void rule__XVariableDeclaration__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11886:1: ( rule__XVariableDeclaration__Group__1__Impl rule__XVariableDeclaration__Group__2 )
+ // InternalOXtype.g:11887:2: rule__XVariableDeclaration__Group__1__Impl rule__XVariableDeclaration__Group__2
+ {
+ pushFollow(FOLLOW_32);
+ rule__XVariableDeclaration__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group__1"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group__1__Impl"
+ // InternalOXtype.g:11894:1: rule__XVariableDeclaration__Group__1__Impl : ( ( rule__XVariableDeclaration__Alternatives_1 ) ) ;
+ public final void rule__XVariableDeclaration__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11898:1: ( ( ( rule__XVariableDeclaration__Alternatives_1 ) ) )
+ // InternalOXtype.g:11899:1: ( ( rule__XVariableDeclaration__Alternatives_1 ) )
+ {
+ // InternalOXtype.g:11899:1: ( ( rule__XVariableDeclaration__Alternatives_1 ) )
+ // InternalOXtype.g:11900:2: ( rule__XVariableDeclaration__Alternatives_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1());
+ }
+ // InternalOXtype.g:11901:2: ( rule__XVariableDeclaration__Alternatives_1 )
+ // InternalOXtype.g:11901:3: rule__XVariableDeclaration__Alternatives_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__Alternatives_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group__2"
+ // InternalOXtype.g:11909:1: rule__XVariableDeclaration__Group__2 : rule__XVariableDeclaration__Group__2__Impl rule__XVariableDeclaration__Group__3 ;
+ public final void rule__XVariableDeclaration__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11913:1: ( rule__XVariableDeclaration__Group__2__Impl rule__XVariableDeclaration__Group__3 )
+ // InternalOXtype.g:11914:2: rule__XVariableDeclaration__Group__2__Impl rule__XVariableDeclaration__Group__3
+ {
+ pushFollow(FOLLOW_16);
+ rule__XVariableDeclaration__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group__2"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group__2__Impl"
+ // InternalOXtype.g:11921:1: rule__XVariableDeclaration__Group__2__Impl : ( ( rule__XVariableDeclaration__Alternatives_2 ) ) ;
+ public final void rule__XVariableDeclaration__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11925:1: ( ( ( rule__XVariableDeclaration__Alternatives_2 ) ) )
+ // InternalOXtype.g:11926:1: ( ( rule__XVariableDeclaration__Alternatives_2 ) )
+ {
+ // InternalOXtype.g:11926:1: ( ( rule__XVariableDeclaration__Alternatives_2 ) )
+ // InternalOXtype.g:11927:2: ( rule__XVariableDeclaration__Alternatives_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2());
+ }
+ // InternalOXtype.g:11928:2: ( rule__XVariableDeclaration__Alternatives_2 )
+ // InternalOXtype.g:11928:3: rule__XVariableDeclaration__Alternatives_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__Alternatives_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group__3"
+ // InternalOXtype.g:11936:1: rule__XVariableDeclaration__Group__3 : rule__XVariableDeclaration__Group__3__Impl ;
+ public final void rule__XVariableDeclaration__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11940:1: ( rule__XVariableDeclaration__Group__3__Impl )
+ // InternalOXtype.g:11941:2: rule__XVariableDeclaration__Group__3__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group__3"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group__3__Impl"
+ // InternalOXtype.g:11947:1: rule__XVariableDeclaration__Group__3__Impl : ( ( rule__XVariableDeclaration__Group_3__0 )? ) ;
+ public final void rule__XVariableDeclaration__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11951:1: ( ( ( rule__XVariableDeclaration__Group_3__0 )? ) )
+ // InternalOXtype.g:11952:1: ( ( rule__XVariableDeclaration__Group_3__0 )? )
+ {
+ // InternalOXtype.g:11952:1: ( ( rule__XVariableDeclaration__Group_3__0 )? )
+ // InternalOXtype.g:11953:2: ( rule__XVariableDeclaration__Group_3__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getGroup_3());
+ }
+ // InternalOXtype.g:11954:2: ( rule__XVariableDeclaration__Group_3__0 )?
+ int alt98=2;
+ int LA98_0 = input.LA(1);
+
+ if ( (LA98_0==13) ) {
+ alt98=1;
+ }
+ switch (alt98) {
+ case 1 :
+ // InternalOXtype.g:11954:3: rule__XVariableDeclaration__Group_3__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__Group_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getGroup_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group_2_0__0"
+ // InternalOXtype.g:11963:1: rule__XVariableDeclaration__Group_2_0__0 : rule__XVariableDeclaration__Group_2_0__0__Impl ;
+ public final void rule__XVariableDeclaration__Group_2_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11967:1: ( rule__XVariableDeclaration__Group_2_0__0__Impl )
+ // InternalOXtype.g:11968:2: rule__XVariableDeclaration__Group_2_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__Group_2_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group_2_0__0"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group_2_0__0__Impl"
+ // InternalOXtype.g:11974:1: rule__XVariableDeclaration__Group_2_0__0__Impl : ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) ) ;
+ public final void rule__XVariableDeclaration__Group_2_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11978:1: ( ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) ) )
+ // InternalOXtype.g:11979:1: ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) )
+ {
+ // InternalOXtype.g:11979:1: ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) )
+ // InternalOXtype.g:11980:2: ( rule__XVariableDeclaration__Group_2_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0());
+ }
+ // InternalOXtype.g:11981:2: ( rule__XVariableDeclaration__Group_2_0_0__0 )
+ // InternalOXtype.g:11981:3: rule__XVariableDeclaration__Group_2_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__Group_2_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group_2_0__0__Impl"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__0"
+ // InternalOXtype.g:11990:1: rule__XVariableDeclaration__Group_2_0_0__0 : rule__XVariableDeclaration__Group_2_0_0__0__Impl rule__XVariableDeclaration__Group_2_0_0__1 ;
+ public final void rule__XVariableDeclaration__Group_2_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:11994:1: ( rule__XVariableDeclaration__Group_2_0_0__0__Impl rule__XVariableDeclaration__Group_2_0_0__1 )
+ // InternalOXtype.g:11995:2: rule__XVariableDeclaration__Group_2_0_0__0__Impl rule__XVariableDeclaration__Group_2_0_0__1
+ {
+ pushFollow(FOLLOW_9);
+ rule__XVariableDeclaration__Group_2_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__Group_2_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__0"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__0__Impl"
+ // InternalOXtype.g:12002:1: rule__XVariableDeclaration__Group_2_0_0__0__Impl : ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) ) ;
+ public final void rule__XVariableDeclaration__Group_2_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12006:1: ( ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) ) )
+ // InternalOXtype.g:12007:1: ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) )
+ {
+ // InternalOXtype.g:12007:1: ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) )
+ // InternalOXtype.g:12008:2: ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0());
+ }
+ // InternalOXtype.g:12009:2: ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 )
+ // InternalOXtype.g:12009:3: rule__XVariableDeclaration__TypeAssignment_2_0_0_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__TypeAssignment_2_0_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__1"
+ // InternalOXtype.g:12017:1: rule__XVariableDeclaration__Group_2_0_0__1 : rule__XVariableDeclaration__Group_2_0_0__1__Impl ;
+ public final void rule__XVariableDeclaration__Group_2_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12021:1: ( rule__XVariableDeclaration__Group_2_0_0__1__Impl )
+ // InternalOXtype.g:12022:2: rule__XVariableDeclaration__Group_2_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__Group_2_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__1"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__1__Impl"
+ // InternalOXtype.g:12028:1: rule__XVariableDeclaration__Group_2_0_0__1__Impl : ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) ) ;
+ public final void rule__XVariableDeclaration__Group_2_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12032:1: ( ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) ) )
+ // InternalOXtype.g:12033:1: ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) )
+ {
+ // InternalOXtype.g:12033:1: ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) )
+ // InternalOXtype.g:12034:2: ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1());
+ }
+ // InternalOXtype.g:12035:2: ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 )
+ // InternalOXtype.g:12035:3: rule__XVariableDeclaration__NameAssignment_2_0_0_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__NameAssignment_2_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group_3__0"
+ // InternalOXtype.g:12044:1: rule__XVariableDeclaration__Group_3__0 : rule__XVariableDeclaration__Group_3__0__Impl rule__XVariableDeclaration__Group_3__1 ;
+ public final void rule__XVariableDeclaration__Group_3__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12048:1: ( rule__XVariableDeclaration__Group_3__0__Impl rule__XVariableDeclaration__Group_3__1 )
+ // InternalOXtype.g:12049:2: rule__XVariableDeclaration__Group_3__0__Impl rule__XVariableDeclaration__Group_3__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XVariableDeclaration__Group_3__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__Group_3__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group_3__0"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group_3__0__Impl"
+ // InternalOXtype.g:12056:1: rule__XVariableDeclaration__Group_3__0__Impl : ( '=' ) ;
+ public final void rule__XVariableDeclaration__Group_3__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12060:1: ( ( '=' ) )
+ // InternalOXtype.g:12061:1: ( '=' )
+ {
+ // InternalOXtype.g:12061:1: ( '=' )
+ // InternalOXtype.g:12062:2: '='
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0());
+ }
+ match(input,13,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group_3__0__Impl"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group_3__1"
+ // InternalOXtype.g:12071:1: rule__XVariableDeclaration__Group_3__1 : rule__XVariableDeclaration__Group_3__1__Impl ;
+ public final void rule__XVariableDeclaration__Group_3__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12075:1: ( rule__XVariableDeclaration__Group_3__1__Impl )
+ // InternalOXtype.g:12076:2: rule__XVariableDeclaration__Group_3__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__Group_3__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group_3__1"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__Group_3__1__Impl"
+ // InternalOXtype.g:12082:1: rule__XVariableDeclaration__Group_3__1__Impl : ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) ) ;
+ public final void rule__XVariableDeclaration__Group_3__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12086:1: ( ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) ) )
+ // InternalOXtype.g:12087:1: ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) )
+ {
+ // InternalOXtype.g:12087:1: ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) )
+ // InternalOXtype.g:12088:2: ( rule__XVariableDeclaration__RightAssignment_3_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1());
+ }
+ // InternalOXtype.g:12089:2: ( rule__XVariableDeclaration__RightAssignment_3_1 )
+ // InternalOXtype.g:12089:3: rule__XVariableDeclaration__RightAssignment_3_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__RightAssignment_3_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__Group_3__1__Impl"
+
+
+ // $ANTLR start "rule__JvmFormalParameter__Group__0"
+ // InternalOXtype.g:12098:1: rule__JvmFormalParameter__Group__0 : rule__JvmFormalParameter__Group__0__Impl rule__JvmFormalParameter__Group__1 ;
+ public final void rule__JvmFormalParameter__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12102:1: ( rule__JvmFormalParameter__Group__0__Impl rule__JvmFormalParameter__Group__1 )
+ // InternalOXtype.g:12103:2: rule__JvmFormalParameter__Group__0__Impl rule__JvmFormalParameter__Group__1
+ {
+ pushFollow(FOLLOW_32);
+ rule__JvmFormalParameter__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmFormalParameter__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmFormalParameter__Group__0"
+
+
+ // $ANTLR start "rule__JvmFormalParameter__Group__0__Impl"
+ // InternalOXtype.g:12110:1: rule__JvmFormalParameter__Group__0__Impl : ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? ) ;
+ public final void rule__JvmFormalParameter__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12114:1: ( ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? ) )
+ // InternalOXtype.g:12115:1: ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? )
+ {
+ // InternalOXtype.g:12115:1: ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? )
+ // InternalOXtype.g:12116:2: ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0());
+ }
+ // InternalOXtype.g:12117:2: ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )?
+ int alt99=2;
+ int LA99_0 = input.LA(1);
+
+ if ( (LA99_0==RULE_ID) ) {
+ int LA99_1 = input.LA(2);
+
+ if ( (LA99_1==RULE_ID||LA99_1==27||LA99_1==43||LA99_1==58) ) {
+ alt99=1;
+ }
+ }
+ else if ( (LA99_0==31||LA99_0==53) ) {
+ alt99=1;
+ }
+ switch (alt99) {
+ case 1 :
+ // InternalOXtype.g:12117:3: rule__JvmFormalParameter__ParameterTypeAssignment_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmFormalParameter__ParameterTypeAssignment_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmFormalParameter__Group__0__Impl"
+
+
+ // $ANTLR start "rule__JvmFormalParameter__Group__1"
+ // InternalOXtype.g:12125:1: rule__JvmFormalParameter__Group__1 : rule__JvmFormalParameter__Group__1__Impl ;
+ public final void rule__JvmFormalParameter__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12129:1: ( rule__JvmFormalParameter__Group__1__Impl )
+ // InternalOXtype.g:12130:2: rule__JvmFormalParameter__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmFormalParameter__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmFormalParameter__Group__1"
+
+
+ // $ANTLR start "rule__JvmFormalParameter__Group__1__Impl"
+ // InternalOXtype.g:12136:1: rule__JvmFormalParameter__Group__1__Impl : ( ( rule__JvmFormalParameter__NameAssignment_1 ) ) ;
+ public final void rule__JvmFormalParameter__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12140:1: ( ( ( rule__JvmFormalParameter__NameAssignment_1 ) ) )
+ // InternalOXtype.g:12141:1: ( ( rule__JvmFormalParameter__NameAssignment_1 ) )
+ {
+ // InternalOXtype.g:12141:1: ( ( rule__JvmFormalParameter__NameAssignment_1 ) )
+ // InternalOXtype.g:12142:2: ( rule__JvmFormalParameter__NameAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1());
+ }
+ // InternalOXtype.g:12143:2: ( rule__JvmFormalParameter__NameAssignment_1 )
+ // InternalOXtype.g:12143:3: rule__JvmFormalParameter__NameAssignment_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmFormalParameter__NameAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmFormalParameter__Group__1__Impl"
+
+
+ // $ANTLR start "rule__FullJvmFormalParameter__Group__0"
+ // InternalOXtype.g:12152:1: rule__FullJvmFormalParameter__Group__0 : rule__FullJvmFormalParameter__Group__0__Impl rule__FullJvmFormalParameter__Group__1 ;
+ public final void rule__FullJvmFormalParameter__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12156:1: ( rule__FullJvmFormalParameter__Group__0__Impl rule__FullJvmFormalParameter__Group__1 )
+ // InternalOXtype.g:12157:2: rule__FullJvmFormalParameter__Group__0__Impl rule__FullJvmFormalParameter__Group__1
+ {
+ pushFollow(FOLLOW_9);
+ rule__FullJvmFormalParameter__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__FullJvmFormalParameter__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FullJvmFormalParameter__Group__0"
+
+
+ // $ANTLR start "rule__FullJvmFormalParameter__Group__0__Impl"
+ // InternalOXtype.g:12164:1: rule__FullJvmFormalParameter__Group__0__Impl : ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) ) ;
+ public final void rule__FullJvmFormalParameter__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12168:1: ( ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) ) )
+ // InternalOXtype.g:12169:1: ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) )
+ {
+ // InternalOXtype.g:12169:1: ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) )
+ // InternalOXtype.g:12170:2: ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0());
+ }
+ // InternalOXtype.g:12171:2: ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 )
+ // InternalOXtype.g:12171:3: rule__FullJvmFormalParameter__ParameterTypeAssignment_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__FullJvmFormalParameter__ParameterTypeAssignment_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FullJvmFormalParameter__Group__0__Impl"
+
+
+ // $ANTLR start "rule__FullJvmFormalParameter__Group__1"
+ // InternalOXtype.g:12179:1: rule__FullJvmFormalParameter__Group__1 : rule__FullJvmFormalParameter__Group__1__Impl ;
+ public final void rule__FullJvmFormalParameter__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12183:1: ( rule__FullJvmFormalParameter__Group__1__Impl )
+ // InternalOXtype.g:12184:2: rule__FullJvmFormalParameter__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__FullJvmFormalParameter__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FullJvmFormalParameter__Group__1"
+
+
+ // $ANTLR start "rule__FullJvmFormalParameter__Group__1__Impl"
+ // InternalOXtype.g:12190:1: rule__FullJvmFormalParameter__Group__1__Impl : ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) ) ;
+ public final void rule__FullJvmFormalParameter__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12194:1: ( ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) ) )
+ // InternalOXtype.g:12195:1: ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) )
+ {
+ // InternalOXtype.g:12195:1: ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) )
+ // InternalOXtype.g:12196:2: ( rule__FullJvmFormalParameter__NameAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1());
+ }
+ // InternalOXtype.g:12197:2: ( rule__FullJvmFormalParameter__NameAssignment_1 )
+ // InternalOXtype.g:12197:3: rule__FullJvmFormalParameter__NameAssignment_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__FullJvmFormalParameter__NameAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FullJvmFormalParameter__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group__0"
+ // InternalOXtype.g:12206:1: rule__XFeatureCall__Group__0 : rule__XFeatureCall__Group__0__Impl rule__XFeatureCall__Group__1 ;
+ public final void rule__XFeatureCall__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12210:1: ( rule__XFeatureCall__Group__0__Impl rule__XFeatureCall__Group__1 )
+ // InternalOXtype.g:12211:2: rule__XFeatureCall__Group__0__Impl rule__XFeatureCall__Group__1
+ {
+ pushFollow(FOLLOW_50);
+ rule__XFeatureCall__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group__0"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group__0__Impl"
+ // InternalOXtype.g:12218:1: rule__XFeatureCall__Group__0__Impl : ( () ) ;
+ public final void rule__XFeatureCall__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12222:1: ( ( () ) )
+ // InternalOXtype.g:12223:1: ( () )
+ {
+ // InternalOXtype.g:12223:1: ( () )
+ // InternalOXtype.g:12224:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0());
+ }
+ // InternalOXtype.g:12225:2: ()
+ // InternalOXtype.g:12225:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group__1"
+ // InternalOXtype.g:12233:1: rule__XFeatureCall__Group__1 : rule__XFeatureCall__Group__1__Impl rule__XFeatureCall__Group__2 ;
+ public final void rule__XFeatureCall__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12237:1: ( rule__XFeatureCall__Group__1__Impl rule__XFeatureCall__Group__2 )
+ // InternalOXtype.g:12238:2: rule__XFeatureCall__Group__1__Impl rule__XFeatureCall__Group__2
+ {
+ pushFollow(FOLLOW_50);
+ rule__XFeatureCall__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group__1"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group__1__Impl"
+ // InternalOXtype.g:12245:1: rule__XFeatureCall__Group__1__Impl : ( ( rule__XFeatureCall__Group_1__0 )? ) ;
+ public final void rule__XFeatureCall__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12249:1: ( ( ( rule__XFeatureCall__Group_1__0 )? ) )
+ // InternalOXtype.g:12250:1: ( ( rule__XFeatureCall__Group_1__0 )? )
+ {
+ // InternalOXtype.g:12250:1: ( ( rule__XFeatureCall__Group_1__0 )? )
+ // InternalOXtype.g:12251:2: ( rule__XFeatureCall__Group_1__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getGroup_1());
+ }
+ // InternalOXtype.g:12252:2: ( rule__XFeatureCall__Group_1__0 )?
+ int alt100=2;
+ int LA100_0 = input.LA(1);
+
+ if ( (LA100_0==27) ) {
+ alt100=1;
+ }
+ switch (alt100) {
+ case 1 :
+ // InternalOXtype.g:12252:3: rule__XFeatureCall__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group__2"
+ // InternalOXtype.g:12260:1: rule__XFeatureCall__Group__2 : rule__XFeatureCall__Group__2__Impl rule__XFeatureCall__Group__3 ;
+ public final void rule__XFeatureCall__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12264:1: ( rule__XFeatureCall__Group__2__Impl rule__XFeatureCall__Group__3 )
+ // InternalOXtype.g:12265:2: rule__XFeatureCall__Group__2__Impl rule__XFeatureCall__Group__3
+ {
+ pushFollow(FOLLOW_51);
+ rule__XFeatureCall__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group__2"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group__2__Impl"
+ // InternalOXtype.g:12272:1: rule__XFeatureCall__Group__2__Impl : ( ( rule__XFeatureCall__FeatureAssignment_2 ) ) ;
+ public final void rule__XFeatureCall__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12276:1: ( ( ( rule__XFeatureCall__FeatureAssignment_2 ) ) )
+ // InternalOXtype.g:12277:1: ( ( rule__XFeatureCall__FeatureAssignment_2 ) )
+ {
+ // InternalOXtype.g:12277:1: ( ( rule__XFeatureCall__FeatureAssignment_2 ) )
+ // InternalOXtype.g:12278:2: ( rule__XFeatureCall__FeatureAssignment_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2());
+ }
+ // InternalOXtype.g:12279:2: ( rule__XFeatureCall__FeatureAssignment_2 )
+ // InternalOXtype.g:12279:3: rule__XFeatureCall__FeatureAssignment_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__FeatureAssignment_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group__3"
+ // InternalOXtype.g:12287:1: rule__XFeatureCall__Group__3 : rule__XFeatureCall__Group__3__Impl rule__XFeatureCall__Group__4 ;
+ public final void rule__XFeatureCall__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12291:1: ( rule__XFeatureCall__Group__3__Impl rule__XFeatureCall__Group__4 )
+ // InternalOXtype.g:12292:2: rule__XFeatureCall__Group__3__Impl rule__XFeatureCall__Group__4
+ {
+ pushFollow(FOLLOW_51);
+ rule__XFeatureCall__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group__3"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group__3__Impl"
+ // InternalOXtype.g:12299:1: rule__XFeatureCall__Group__3__Impl : ( ( rule__XFeatureCall__Group_3__0 )? ) ;
+ public final void rule__XFeatureCall__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12303:1: ( ( ( rule__XFeatureCall__Group_3__0 )? ) )
+ // InternalOXtype.g:12304:1: ( ( rule__XFeatureCall__Group_3__0 )? )
+ {
+ // InternalOXtype.g:12304:1: ( ( rule__XFeatureCall__Group_3__0 )? )
+ // InternalOXtype.g:12305:2: ( rule__XFeatureCall__Group_3__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getGroup_3());
+ }
+ // InternalOXtype.g:12306:2: ( rule__XFeatureCall__Group_3__0 )?
+ int alt101=2;
+ alt101 = dfa101.predict(input);
+ switch (alt101) {
+ case 1 :
+ // InternalOXtype.g:12306:3: rule__XFeatureCall__Group_3__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getGroup_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group__4"
+ // InternalOXtype.g:12314:1: rule__XFeatureCall__Group__4 : rule__XFeatureCall__Group__4__Impl ;
+ public final void rule__XFeatureCall__Group__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12318:1: ( rule__XFeatureCall__Group__4__Impl )
+ // InternalOXtype.g:12319:2: rule__XFeatureCall__Group__4__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group__4"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group__4__Impl"
+ // InternalOXtype.g:12325:1: rule__XFeatureCall__Group__4__Impl : ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? ) ;
+ public final void rule__XFeatureCall__Group__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12329:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? ) )
+ // InternalOXtype.g:12330:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? )
+ {
+ // InternalOXtype.g:12330:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? )
+ // InternalOXtype.g:12331:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4());
+ }
+ // InternalOXtype.g:12332:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )?
+ int alt102=2;
+ alt102 = dfa102.predict(input);
+ switch (alt102) {
+ case 1 :
+ // InternalOXtype.g:12332:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_4
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__FeatureCallArgumentsAssignment_4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group__4__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_1__0"
+ // InternalOXtype.g:12341:1: rule__XFeatureCall__Group_1__0 : rule__XFeatureCall__Group_1__0__Impl rule__XFeatureCall__Group_1__1 ;
+ public final void rule__XFeatureCall__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12345:1: ( rule__XFeatureCall__Group_1__0__Impl rule__XFeatureCall__Group_1__1 )
+ // InternalOXtype.g:12346:2: rule__XFeatureCall__Group_1__0__Impl rule__XFeatureCall__Group_1__1
+ {
+ pushFollow(FOLLOW_52);
+ rule__XFeatureCall__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_1__0"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_1__0__Impl"
+ // InternalOXtype.g:12353:1: rule__XFeatureCall__Group_1__0__Impl : ( '<' ) ;
+ public final void rule__XFeatureCall__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12357:1: ( ( '<' ) )
+ // InternalOXtype.g:12358:1: ( '<' )
+ {
+ // InternalOXtype.g:12358:1: ( '<' )
+ // InternalOXtype.g:12359:2: '<'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0());
+ }
+ match(input,27,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_1__1"
+ // InternalOXtype.g:12368:1: rule__XFeatureCall__Group_1__1 : rule__XFeatureCall__Group_1__1__Impl rule__XFeatureCall__Group_1__2 ;
+ public final void rule__XFeatureCall__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12372:1: ( rule__XFeatureCall__Group_1__1__Impl rule__XFeatureCall__Group_1__2 )
+ // InternalOXtype.g:12373:2: rule__XFeatureCall__Group_1__1__Impl rule__XFeatureCall__Group_1__2
+ {
+ pushFollow(FOLLOW_53);
+ rule__XFeatureCall__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_1__1"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_1__1__Impl"
+ // InternalOXtype.g:12380:1: rule__XFeatureCall__Group_1__1__Impl : ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) ) ;
+ public final void rule__XFeatureCall__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12384:1: ( ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) ) )
+ // InternalOXtype.g:12385:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) )
+ {
+ // InternalOXtype.g:12385:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) )
+ // InternalOXtype.g:12386:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1());
+ }
+ // InternalOXtype.g:12387:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 )
+ // InternalOXtype.g:12387:3: rule__XFeatureCall__TypeArgumentsAssignment_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__TypeArgumentsAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_1__2"
+ // InternalOXtype.g:12395:1: rule__XFeatureCall__Group_1__2 : rule__XFeatureCall__Group_1__2__Impl rule__XFeatureCall__Group_1__3 ;
+ public final void rule__XFeatureCall__Group_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12399:1: ( rule__XFeatureCall__Group_1__2__Impl rule__XFeatureCall__Group_1__3 )
+ // InternalOXtype.g:12400:2: rule__XFeatureCall__Group_1__2__Impl rule__XFeatureCall__Group_1__3
+ {
+ pushFollow(FOLLOW_53);
+ rule__XFeatureCall__Group_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group_1__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_1__2"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_1__2__Impl"
+ // InternalOXtype.g:12407:1: rule__XFeatureCall__Group_1__2__Impl : ( ( rule__XFeatureCall__Group_1_2__0 )* ) ;
+ public final void rule__XFeatureCall__Group_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12411:1: ( ( ( rule__XFeatureCall__Group_1_2__0 )* ) )
+ // InternalOXtype.g:12412:1: ( ( rule__XFeatureCall__Group_1_2__0 )* )
+ {
+ // InternalOXtype.g:12412:1: ( ( rule__XFeatureCall__Group_1_2__0 )* )
+ // InternalOXtype.g:12413:2: ( rule__XFeatureCall__Group_1_2__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getGroup_1_2());
+ }
+ // InternalOXtype.g:12414:2: ( rule__XFeatureCall__Group_1_2__0 )*
+ loop103:
+ do {
+ int alt103=2;
+ int LA103_0 = input.LA(1);
+
+ if ( (LA103_0==55) ) {
+ alt103=1;
+ }
+
+
+ switch (alt103) {
+ case 1 :
+ // InternalOXtype.g:12414:3: rule__XFeatureCall__Group_1_2__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XFeatureCall__Group_1_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop103;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getGroup_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_1__2__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_1__3"
+ // InternalOXtype.g:12422:1: rule__XFeatureCall__Group_1__3 : rule__XFeatureCall__Group_1__3__Impl ;
+ public final void rule__XFeatureCall__Group_1__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12426:1: ( rule__XFeatureCall__Group_1__3__Impl )
+ // InternalOXtype.g:12427:2: rule__XFeatureCall__Group_1__3__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group_1__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_1__3"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_1__3__Impl"
+ // InternalOXtype.g:12433:1: rule__XFeatureCall__Group_1__3__Impl : ( '>' ) ;
+ public final void rule__XFeatureCall__Group_1__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12437:1: ( ( '>' ) )
+ // InternalOXtype.g:12438:1: ( '>' )
+ {
+ // InternalOXtype.g:12438:1: ( '>' )
+ // InternalOXtype.g:12439:2: '>'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3());
+ }
+ match(input,26,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_1__3__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_1_2__0"
+ // InternalOXtype.g:12449:1: rule__XFeatureCall__Group_1_2__0 : rule__XFeatureCall__Group_1_2__0__Impl rule__XFeatureCall__Group_1_2__1 ;
+ public final void rule__XFeatureCall__Group_1_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12453:1: ( rule__XFeatureCall__Group_1_2__0__Impl rule__XFeatureCall__Group_1_2__1 )
+ // InternalOXtype.g:12454:2: rule__XFeatureCall__Group_1_2__0__Impl rule__XFeatureCall__Group_1_2__1
+ {
+ pushFollow(FOLLOW_52);
+ rule__XFeatureCall__Group_1_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group_1_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_1_2__0"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_1_2__0__Impl"
+ // InternalOXtype.g:12461:1: rule__XFeatureCall__Group_1_2__0__Impl : ( ',' ) ;
+ public final void rule__XFeatureCall__Group_1_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12465:1: ( ( ',' ) )
+ // InternalOXtype.g:12466:1: ( ',' )
+ {
+ // InternalOXtype.g:12466:1: ( ',' )
+ // InternalOXtype.g:12467:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_1_2__0__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_1_2__1"
+ // InternalOXtype.g:12476:1: rule__XFeatureCall__Group_1_2__1 : rule__XFeatureCall__Group_1_2__1__Impl ;
+ public final void rule__XFeatureCall__Group_1_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12480:1: ( rule__XFeatureCall__Group_1_2__1__Impl )
+ // InternalOXtype.g:12481:2: rule__XFeatureCall__Group_1_2__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group_1_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_1_2__1"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_1_2__1__Impl"
+ // InternalOXtype.g:12487:1: rule__XFeatureCall__Group_1_2__1__Impl : ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) ) ;
+ public final void rule__XFeatureCall__Group_1_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12491:1: ( ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) ) )
+ // InternalOXtype.g:12492:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) )
+ {
+ // InternalOXtype.g:12492:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) )
+ // InternalOXtype.g:12493:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1());
+ }
+ // InternalOXtype.g:12494:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 )
+ // InternalOXtype.g:12494:3: rule__XFeatureCall__TypeArgumentsAssignment_1_2_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__TypeArgumentsAssignment_1_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_1_2__1__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_3__0"
+ // InternalOXtype.g:12503:1: rule__XFeatureCall__Group_3__0 : rule__XFeatureCall__Group_3__0__Impl rule__XFeatureCall__Group_3__1 ;
+ public final void rule__XFeatureCall__Group_3__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12507:1: ( rule__XFeatureCall__Group_3__0__Impl rule__XFeatureCall__Group_3__1 )
+ // InternalOXtype.g:12508:2: rule__XFeatureCall__Group_3__0__Impl rule__XFeatureCall__Group_3__1
+ {
+ pushFollow(FOLLOW_54);
+ rule__XFeatureCall__Group_3__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group_3__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_3__0"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_3__0__Impl"
+ // InternalOXtype.g:12515:1: rule__XFeatureCall__Group_3__0__Impl : ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) ) ;
+ public final void rule__XFeatureCall__Group_3__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12519:1: ( ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) ) )
+ // InternalOXtype.g:12520:1: ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) )
+ {
+ // InternalOXtype.g:12520:1: ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) )
+ // InternalOXtype.g:12521:2: ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0());
+ }
+ // InternalOXtype.g:12522:2: ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 )
+ // InternalOXtype.g:12522:3: rule__XFeatureCall__ExplicitOperationCallAssignment_3_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__ExplicitOperationCallAssignment_3_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_3__0__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_3__1"
+ // InternalOXtype.g:12530:1: rule__XFeatureCall__Group_3__1 : rule__XFeatureCall__Group_3__1__Impl rule__XFeatureCall__Group_3__2 ;
+ public final void rule__XFeatureCall__Group_3__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12534:1: ( rule__XFeatureCall__Group_3__1__Impl rule__XFeatureCall__Group_3__2 )
+ // InternalOXtype.g:12535:2: rule__XFeatureCall__Group_3__1__Impl rule__XFeatureCall__Group_3__2
+ {
+ pushFollow(FOLLOW_54);
+ rule__XFeatureCall__Group_3__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group_3__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_3__1"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_3__1__Impl"
+ // InternalOXtype.g:12542:1: rule__XFeatureCall__Group_3__1__Impl : ( ( rule__XFeatureCall__Alternatives_3_1 )? ) ;
+ public final void rule__XFeatureCall__Group_3__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12546:1: ( ( ( rule__XFeatureCall__Alternatives_3_1 )? ) )
+ // InternalOXtype.g:12547:1: ( ( rule__XFeatureCall__Alternatives_3_1 )? )
+ {
+ // InternalOXtype.g:12547:1: ( ( rule__XFeatureCall__Alternatives_3_1 )? )
+ // InternalOXtype.g:12548:2: ( rule__XFeatureCall__Alternatives_3_1 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1());
+ }
+ // InternalOXtype.g:12549:2: ( rule__XFeatureCall__Alternatives_3_1 )?
+ int alt104=2;
+ int LA104_0 = input.LA(1);
+
+ if ( ((LA104_0>=RULE_ID && LA104_0<=RULE_STRING)||LA104_0==27||LA104_0==31||(LA104_0>=34 && LA104_0<=35)||LA104_0==40||(LA104_0>=45 && LA104_0<=50)||LA104_0==53||(LA104_0>=57 && LA104_0<=58)||LA104_0==61||LA104_0==63||LA104_0==65||(LA104_0>=69 && LA104_0<=77)||LA104_0==79||LA104_0==86||LA104_0==88) ) {
+ alt104=1;
+ }
+ switch (alt104) {
+ case 1 :
+ // InternalOXtype.g:12549:3: rule__XFeatureCall__Alternatives_3_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Alternatives_3_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_3__1__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_3__2"
+ // InternalOXtype.g:12557:1: rule__XFeatureCall__Group_3__2 : rule__XFeatureCall__Group_3__2__Impl ;
+ public final void rule__XFeatureCall__Group_3__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12561:1: ( rule__XFeatureCall__Group_3__2__Impl )
+ // InternalOXtype.g:12562:2: rule__XFeatureCall__Group_3__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group_3__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_3__2"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_3__2__Impl"
+ // InternalOXtype.g:12568:1: rule__XFeatureCall__Group_3__2__Impl : ( ')' ) ;
+ public final void rule__XFeatureCall__Group_3__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12572:1: ( ( ')' ) )
+ // InternalOXtype.g:12573:1: ( ')' )
+ {
+ // InternalOXtype.g:12573:1: ( ')' )
+ // InternalOXtype.g:12574:2: ')'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2());
+ }
+ match(input,54,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_3__2__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_3_1_1__0"
+ // InternalOXtype.g:12584:1: rule__XFeatureCall__Group_3_1_1__0 : rule__XFeatureCall__Group_3_1_1__0__Impl rule__XFeatureCall__Group_3_1_1__1 ;
+ public final void rule__XFeatureCall__Group_3_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12588:1: ( rule__XFeatureCall__Group_3_1_1__0__Impl rule__XFeatureCall__Group_3_1_1__1 )
+ // InternalOXtype.g:12589:2: rule__XFeatureCall__Group_3_1_1__0__Impl rule__XFeatureCall__Group_3_1_1__1
+ {
+ pushFollow(FOLLOW_13);
+ rule__XFeatureCall__Group_3_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group_3_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_3_1_1__0"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_3_1_1__0__Impl"
+ // InternalOXtype.g:12596:1: rule__XFeatureCall__Group_3_1_1__0__Impl : ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) ) ;
+ public final void rule__XFeatureCall__Group_3_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12600:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) ) )
+ // InternalOXtype.g:12601:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) )
+ {
+ // InternalOXtype.g:12601:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) )
+ // InternalOXtype.g:12602:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0());
+ }
+ // InternalOXtype.g:12603:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 )
+ // InternalOXtype.g:12603:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_3_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_3_1_1__1"
+ // InternalOXtype.g:12611:1: rule__XFeatureCall__Group_3_1_1__1 : rule__XFeatureCall__Group_3_1_1__1__Impl ;
+ public final void rule__XFeatureCall__Group_3_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12615:1: ( rule__XFeatureCall__Group_3_1_1__1__Impl )
+ // InternalOXtype.g:12616:2: rule__XFeatureCall__Group_3_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group_3_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_3_1_1__1"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_3_1_1__1__Impl"
+ // InternalOXtype.g:12622:1: rule__XFeatureCall__Group_3_1_1__1__Impl : ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* ) ;
+ public final void rule__XFeatureCall__Group_3_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12626:1: ( ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* ) )
+ // InternalOXtype.g:12627:1: ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* )
+ {
+ // InternalOXtype.g:12627:1: ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* )
+ // InternalOXtype.g:12628:2: ( rule__XFeatureCall__Group_3_1_1_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1());
+ }
+ // InternalOXtype.g:12629:2: ( rule__XFeatureCall__Group_3_1_1_1__0 )*
+ loop105:
+ do {
+ int alt105=2;
+ int LA105_0 = input.LA(1);
+
+ if ( (LA105_0==55) ) {
+ alt105=1;
+ }
+
+
+ switch (alt105) {
+ case 1 :
+ // InternalOXtype.g:12629:3: rule__XFeatureCall__Group_3_1_1_1__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XFeatureCall__Group_3_1_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop105;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_3_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__0"
+ // InternalOXtype.g:12638:1: rule__XFeatureCall__Group_3_1_1_1__0 : rule__XFeatureCall__Group_3_1_1_1__0__Impl rule__XFeatureCall__Group_3_1_1_1__1 ;
+ public final void rule__XFeatureCall__Group_3_1_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12642:1: ( rule__XFeatureCall__Group_3_1_1_1__0__Impl rule__XFeatureCall__Group_3_1_1_1__1 )
+ // InternalOXtype.g:12643:2: rule__XFeatureCall__Group_3_1_1_1__0__Impl rule__XFeatureCall__Group_3_1_1_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XFeatureCall__Group_3_1_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group_3_1_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__0"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__0__Impl"
+ // InternalOXtype.g:12650:1: rule__XFeatureCall__Group_3_1_1_1__0__Impl : ( ',' ) ;
+ public final void rule__XFeatureCall__Group_3_1_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12654:1: ( ( ',' ) )
+ // InternalOXtype.g:12655:1: ( ',' )
+ {
+ // InternalOXtype.g:12655:1: ( ',' )
+ // InternalOXtype.g:12656:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__1"
+ // InternalOXtype.g:12665:1: rule__XFeatureCall__Group_3_1_1_1__1 : rule__XFeatureCall__Group_3_1_1_1__1__Impl ;
+ public final void rule__XFeatureCall__Group_3_1_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12669:1: ( rule__XFeatureCall__Group_3_1_1_1__1__Impl )
+ // InternalOXtype.g:12670:2: rule__XFeatureCall__Group_3_1_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group_3_1_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__1"
+
+
+ // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__1__Impl"
+ // InternalOXtype.g:12676:1: rule__XFeatureCall__Group_3_1_1_1__1__Impl : ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) ) ;
+ public final void rule__XFeatureCall__Group_3_1_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12680:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) ) )
+ // InternalOXtype.g:12681:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) )
+ {
+ // InternalOXtype.g:12681:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) )
+ // InternalOXtype.g:12682:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1());
+ }
+ // InternalOXtype.g:12683:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 )
+ // InternalOXtype.g:12683:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group__0"
+ // InternalOXtype.g:12692:1: rule__XConstructorCall__Group__0 : rule__XConstructorCall__Group__0__Impl rule__XConstructorCall__Group__1 ;
+ public final void rule__XConstructorCall__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12696:1: ( rule__XConstructorCall__Group__0__Impl rule__XConstructorCall__Group__1 )
+ // InternalOXtype.g:12697:2: rule__XConstructorCall__Group__0__Impl rule__XConstructorCall__Group__1
+ {
+ pushFollow(FOLLOW_78);
+ rule__XConstructorCall__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group__0"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group__0__Impl"
+ // InternalOXtype.g:12704:1: rule__XConstructorCall__Group__0__Impl : ( () ) ;
+ public final void rule__XConstructorCall__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12708:1: ( ( () ) )
+ // InternalOXtype.g:12709:1: ( () )
+ {
+ // InternalOXtype.g:12709:1: ( () )
+ // InternalOXtype.g:12710:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0());
+ }
+ // InternalOXtype.g:12711:2: ()
+ // InternalOXtype.g:12711:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group__1"
+ // InternalOXtype.g:12719:1: rule__XConstructorCall__Group__1 : rule__XConstructorCall__Group__1__Impl rule__XConstructorCall__Group__2 ;
+ public final void rule__XConstructorCall__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12723:1: ( rule__XConstructorCall__Group__1__Impl rule__XConstructorCall__Group__2 )
+ // InternalOXtype.g:12724:2: rule__XConstructorCall__Group__1__Impl rule__XConstructorCall__Group__2
+ {
+ pushFollow(FOLLOW_9);
+ rule__XConstructorCall__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group__1"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group__1__Impl"
+ // InternalOXtype.g:12731:1: rule__XConstructorCall__Group__1__Impl : ( 'new' ) ;
+ public final void rule__XConstructorCall__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12735:1: ( ( 'new' ) )
+ // InternalOXtype.g:12736:1: ( 'new' )
+ {
+ // InternalOXtype.g:12736:1: ( 'new' )
+ // InternalOXtype.g:12737:2: 'new'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getNewKeyword_1());
+ }
+ match(input,72,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getNewKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group__2"
+ // InternalOXtype.g:12746:1: rule__XConstructorCall__Group__2 : rule__XConstructorCall__Group__2__Impl rule__XConstructorCall__Group__3 ;
+ public final void rule__XConstructorCall__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12750:1: ( rule__XConstructorCall__Group__2__Impl rule__XConstructorCall__Group__3 )
+ // InternalOXtype.g:12751:2: rule__XConstructorCall__Group__2__Impl rule__XConstructorCall__Group__3
+ {
+ pushFollow(FOLLOW_79);
+ rule__XConstructorCall__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group__2"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group__2__Impl"
+ // InternalOXtype.g:12758:1: rule__XConstructorCall__Group__2__Impl : ( ( rule__XConstructorCall__ConstructorAssignment_2 ) ) ;
+ public final void rule__XConstructorCall__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12762:1: ( ( ( rule__XConstructorCall__ConstructorAssignment_2 ) ) )
+ // InternalOXtype.g:12763:1: ( ( rule__XConstructorCall__ConstructorAssignment_2 ) )
+ {
+ // InternalOXtype.g:12763:1: ( ( rule__XConstructorCall__ConstructorAssignment_2 ) )
+ // InternalOXtype.g:12764:2: ( rule__XConstructorCall__ConstructorAssignment_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2());
+ }
+ // InternalOXtype.g:12765:2: ( rule__XConstructorCall__ConstructorAssignment_2 )
+ // InternalOXtype.g:12765:3: rule__XConstructorCall__ConstructorAssignment_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__ConstructorAssignment_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group__3"
+ // InternalOXtype.g:12773:1: rule__XConstructorCall__Group__3 : rule__XConstructorCall__Group__3__Impl rule__XConstructorCall__Group__4 ;
+ public final void rule__XConstructorCall__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12777:1: ( rule__XConstructorCall__Group__3__Impl rule__XConstructorCall__Group__4 )
+ // InternalOXtype.g:12778:2: rule__XConstructorCall__Group__3__Impl rule__XConstructorCall__Group__4
+ {
+ pushFollow(FOLLOW_79);
+ rule__XConstructorCall__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group__3"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group__3__Impl"
+ // InternalOXtype.g:12785:1: rule__XConstructorCall__Group__3__Impl : ( ( rule__XConstructorCall__Group_3__0 )? ) ;
+ public final void rule__XConstructorCall__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12789:1: ( ( ( rule__XConstructorCall__Group_3__0 )? ) )
+ // InternalOXtype.g:12790:1: ( ( rule__XConstructorCall__Group_3__0 )? )
+ {
+ // InternalOXtype.g:12790:1: ( ( rule__XConstructorCall__Group_3__0 )? )
+ // InternalOXtype.g:12791:2: ( rule__XConstructorCall__Group_3__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getGroup_3());
+ }
+ // InternalOXtype.g:12792:2: ( rule__XConstructorCall__Group_3__0 )?
+ int alt106=2;
+ alt106 = dfa106.predict(input);
+ switch (alt106) {
+ case 1 :
+ // InternalOXtype.g:12792:3: rule__XConstructorCall__Group_3__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getGroup_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group__4"
+ // InternalOXtype.g:12800:1: rule__XConstructorCall__Group__4 : rule__XConstructorCall__Group__4__Impl rule__XConstructorCall__Group__5 ;
+ public final void rule__XConstructorCall__Group__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12804:1: ( rule__XConstructorCall__Group__4__Impl rule__XConstructorCall__Group__5 )
+ // InternalOXtype.g:12805:2: rule__XConstructorCall__Group__4__Impl rule__XConstructorCall__Group__5
+ {
+ pushFollow(FOLLOW_79);
+ rule__XConstructorCall__Group__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group__5();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group__4"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group__4__Impl"
+ // InternalOXtype.g:12812:1: rule__XConstructorCall__Group__4__Impl : ( ( rule__XConstructorCall__Group_4__0 )? ) ;
+ public final void rule__XConstructorCall__Group__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12816:1: ( ( ( rule__XConstructorCall__Group_4__0 )? ) )
+ // InternalOXtype.g:12817:1: ( ( rule__XConstructorCall__Group_4__0 )? )
+ {
+ // InternalOXtype.g:12817:1: ( ( rule__XConstructorCall__Group_4__0 )? )
+ // InternalOXtype.g:12818:2: ( rule__XConstructorCall__Group_4__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getGroup_4());
+ }
+ // InternalOXtype.g:12819:2: ( rule__XConstructorCall__Group_4__0 )?
+ int alt107=2;
+ alt107 = dfa107.predict(input);
+ switch (alt107) {
+ case 1 :
+ // InternalOXtype.g:12819:3: rule__XConstructorCall__Group_4__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_4__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getGroup_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group__4__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group__5"
+ // InternalOXtype.g:12827:1: rule__XConstructorCall__Group__5 : rule__XConstructorCall__Group__5__Impl ;
+ public final void rule__XConstructorCall__Group__5() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12831:1: ( rule__XConstructorCall__Group__5__Impl )
+ // InternalOXtype.g:12832:2: rule__XConstructorCall__Group__5__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group__5__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group__5"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group__5__Impl"
+ // InternalOXtype.g:12838:1: rule__XConstructorCall__Group__5__Impl : ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? ) ;
+ public final void rule__XConstructorCall__Group__5__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12842:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? ) )
+ // InternalOXtype.g:12843:1: ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? )
+ {
+ // InternalOXtype.g:12843:1: ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? )
+ // InternalOXtype.g:12844:2: ( rule__XConstructorCall__ArgumentsAssignment_5 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5());
+ }
+ // InternalOXtype.g:12845:2: ( rule__XConstructorCall__ArgumentsAssignment_5 )?
+ int alt108=2;
+ alt108 = dfa108.predict(input);
+ switch (alt108) {
+ case 1 :
+ // InternalOXtype.g:12845:3: rule__XConstructorCall__ArgumentsAssignment_5
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__ArgumentsAssignment_5();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group__5__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_3__0"
+ // InternalOXtype.g:12854:1: rule__XConstructorCall__Group_3__0 : rule__XConstructorCall__Group_3__0__Impl rule__XConstructorCall__Group_3__1 ;
+ public final void rule__XConstructorCall__Group_3__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12858:1: ( rule__XConstructorCall__Group_3__0__Impl rule__XConstructorCall__Group_3__1 )
+ // InternalOXtype.g:12859:2: rule__XConstructorCall__Group_3__0__Impl rule__XConstructorCall__Group_3__1
+ {
+ pushFollow(FOLLOW_52);
+ rule__XConstructorCall__Group_3__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_3__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_3__0"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_3__0__Impl"
+ // InternalOXtype.g:12866:1: rule__XConstructorCall__Group_3__0__Impl : ( ( '<' ) ) ;
+ public final void rule__XConstructorCall__Group_3__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12870:1: ( ( ( '<' ) ) )
+ // InternalOXtype.g:12871:1: ( ( '<' ) )
+ {
+ // InternalOXtype.g:12871:1: ( ( '<' ) )
+ // InternalOXtype.g:12872:2: ( '<' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0());
+ }
+ // InternalOXtype.g:12873:2: ( '<' )
+ // InternalOXtype.g:12873:3: '<'
+ {
+ match(input,27,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_3__0__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_3__1"
+ // InternalOXtype.g:12881:1: rule__XConstructorCall__Group_3__1 : rule__XConstructorCall__Group_3__1__Impl rule__XConstructorCall__Group_3__2 ;
+ public final void rule__XConstructorCall__Group_3__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12885:1: ( rule__XConstructorCall__Group_3__1__Impl rule__XConstructorCall__Group_3__2 )
+ // InternalOXtype.g:12886:2: rule__XConstructorCall__Group_3__1__Impl rule__XConstructorCall__Group_3__2
+ {
+ pushFollow(FOLLOW_53);
+ rule__XConstructorCall__Group_3__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_3__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_3__1"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_3__1__Impl"
+ // InternalOXtype.g:12893:1: rule__XConstructorCall__Group_3__1__Impl : ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) ) ;
+ public final void rule__XConstructorCall__Group_3__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12897:1: ( ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) ) )
+ // InternalOXtype.g:12898:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) )
+ {
+ // InternalOXtype.g:12898:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) )
+ // InternalOXtype.g:12899:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1());
+ }
+ // InternalOXtype.g:12900:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 )
+ // InternalOXtype.g:12900:3: rule__XConstructorCall__TypeArgumentsAssignment_3_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__TypeArgumentsAssignment_3_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_3__1__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_3__2"
+ // InternalOXtype.g:12908:1: rule__XConstructorCall__Group_3__2 : rule__XConstructorCall__Group_3__2__Impl rule__XConstructorCall__Group_3__3 ;
+ public final void rule__XConstructorCall__Group_3__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12912:1: ( rule__XConstructorCall__Group_3__2__Impl rule__XConstructorCall__Group_3__3 )
+ // InternalOXtype.g:12913:2: rule__XConstructorCall__Group_3__2__Impl rule__XConstructorCall__Group_3__3
+ {
+ pushFollow(FOLLOW_53);
+ rule__XConstructorCall__Group_3__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_3__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_3__2"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_3__2__Impl"
+ // InternalOXtype.g:12920:1: rule__XConstructorCall__Group_3__2__Impl : ( ( rule__XConstructorCall__Group_3_2__0 )* ) ;
+ public final void rule__XConstructorCall__Group_3__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12924:1: ( ( ( rule__XConstructorCall__Group_3_2__0 )* ) )
+ // InternalOXtype.g:12925:1: ( ( rule__XConstructorCall__Group_3_2__0 )* )
+ {
+ // InternalOXtype.g:12925:1: ( ( rule__XConstructorCall__Group_3_2__0 )* )
+ // InternalOXtype.g:12926:2: ( rule__XConstructorCall__Group_3_2__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getGroup_3_2());
+ }
+ // InternalOXtype.g:12927:2: ( rule__XConstructorCall__Group_3_2__0 )*
+ loop109:
+ do {
+ int alt109=2;
+ int LA109_0 = input.LA(1);
+
+ if ( (LA109_0==55) ) {
+ alt109=1;
+ }
+
+
+ switch (alt109) {
+ case 1 :
+ // InternalOXtype.g:12927:3: rule__XConstructorCall__Group_3_2__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XConstructorCall__Group_3_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop109;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getGroup_3_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_3__2__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_3__3"
+ // InternalOXtype.g:12935:1: rule__XConstructorCall__Group_3__3 : rule__XConstructorCall__Group_3__3__Impl ;
+ public final void rule__XConstructorCall__Group_3__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12939:1: ( rule__XConstructorCall__Group_3__3__Impl )
+ // InternalOXtype.g:12940:2: rule__XConstructorCall__Group_3__3__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_3__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_3__3"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_3__3__Impl"
+ // InternalOXtype.g:12946:1: rule__XConstructorCall__Group_3__3__Impl : ( '>' ) ;
+ public final void rule__XConstructorCall__Group_3__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12950:1: ( ( '>' ) )
+ // InternalOXtype.g:12951:1: ( '>' )
+ {
+ // InternalOXtype.g:12951:1: ( '>' )
+ // InternalOXtype.g:12952:2: '>'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3());
+ }
+ match(input,26,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_3__3__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_3_2__0"
+ // InternalOXtype.g:12962:1: rule__XConstructorCall__Group_3_2__0 : rule__XConstructorCall__Group_3_2__0__Impl rule__XConstructorCall__Group_3_2__1 ;
+ public final void rule__XConstructorCall__Group_3_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12966:1: ( rule__XConstructorCall__Group_3_2__0__Impl rule__XConstructorCall__Group_3_2__1 )
+ // InternalOXtype.g:12967:2: rule__XConstructorCall__Group_3_2__0__Impl rule__XConstructorCall__Group_3_2__1
+ {
+ pushFollow(FOLLOW_52);
+ rule__XConstructorCall__Group_3_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_3_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_3_2__0"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_3_2__0__Impl"
+ // InternalOXtype.g:12974:1: rule__XConstructorCall__Group_3_2__0__Impl : ( ',' ) ;
+ public final void rule__XConstructorCall__Group_3_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12978:1: ( ( ',' ) )
+ // InternalOXtype.g:12979:1: ( ',' )
+ {
+ // InternalOXtype.g:12979:1: ( ',' )
+ // InternalOXtype.g:12980:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_3_2__0__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_3_2__1"
+ // InternalOXtype.g:12989:1: rule__XConstructorCall__Group_3_2__1 : rule__XConstructorCall__Group_3_2__1__Impl ;
+ public final void rule__XConstructorCall__Group_3_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:12993:1: ( rule__XConstructorCall__Group_3_2__1__Impl )
+ // InternalOXtype.g:12994:2: rule__XConstructorCall__Group_3_2__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_3_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_3_2__1"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_3_2__1__Impl"
+ // InternalOXtype.g:13000:1: rule__XConstructorCall__Group_3_2__1__Impl : ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) ) ;
+ public final void rule__XConstructorCall__Group_3_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13004:1: ( ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) ) )
+ // InternalOXtype.g:13005:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) )
+ {
+ // InternalOXtype.g:13005:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) )
+ // InternalOXtype.g:13006:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1());
+ }
+ // InternalOXtype.g:13007:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 )
+ // InternalOXtype.g:13007:3: rule__XConstructorCall__TypeArgumentsAssignment_3_2_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__TypeArgumentsAssignment_3_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_3_2__1__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_4__0"
+ // InternalOXtype.g:13016:1: rule__XConstructorCall__Group_4__0 : rule__XConstructorCall__Group_4__0__Impl rule__XConstructorCall__Group_4__1 ;
+ public final void rule__XConstructorCall__Group_4__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13020:1: ( rule__XConstructorCall__Group_4__0__Impl rule__XConstructorCall__Group_4__1 )
+ // InternalOXtype.g:13021:2: rule__XConstructorCall__Group_4__0__Impl rule__XConstructorCall__Group_4__1
+ {
+ pushFollow(FOLLOW_54);
+ rule__XConstructorCall__Group_4__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_4__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_4__0"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_4__0__Impl"
+ // InternalOXtype.g:13028:1: rule__XConstructorCall__Group_4__0__Impl : ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) ) ;
+ public final void rule__XConstructorCall__Group_4__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13032:1: ( ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) ) )
+ // InternalOXtype.g:13033:1: ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) )
+ {
+ // InternalOXtype.g:13033:1: ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) )
+ // InternalOXtype.g:13034:2: ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0());
+ }
+ // InternalOXtype.g:13035:2: ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 )
+ // InternalOXtype.g:13035:3: rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_4__0__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_4__1"
+ // InternalOXtype.g:13043:1: rule__XConstructorCall__Group_4__1 : rule__XConstructorCall__Group_4__1__Impl rule__XConstructorCall__Group_4__2 ;
+ public final void rule__XConstructorCall__Group_4__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13047:1: ( rule__XConstructorCall__Group_4__1__Impl rule__XConstructorCall__Group_4__2 )
+ // InternalOXtype.g:13048:2: rule__XConstructorCall__Group_4__1__Impl rule__XConstructorCall__Group_4__2
+ {
+ pushFollow(FOLLOW_54);
+ rule__XConstructorCall__Group_4__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_4__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_4__1"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_4__1__Impl"
+ // InternalOXtype.g:13055:1: rule__XConstructorCall__Group_4__1__Impl : ( ( rule__XConstructorCall__Alternatives_4_1 )? ) ;
+ public final void rule__XConstructorCall__Group_4__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13059:1: ( ( ( rule__XConstructorCall__Alternatives_4_1 )? ) )
+ // InternalOXtype.g:13060:1: ( ( rule__XConstructorCall__Alternatives_4_1 )? )
+ {
+ // InternalOXtype.g:13060:1: ( ( rule__XConstructorCall__Alternatives_4_1 )? )
+ // InternalOXtype.g:13061:2: ( rule__XConstructorCall__Alternatives_4_1 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1());
+ }
+ // InternalOXtype.g:13062:2: ( rule__XConstructorCall__Alternatives_4_1 )?
+ int alt110=2;
+ int LA110_0 = input.LA(1);
+
+ if ( ((LA110_0>=RULE_ID && LA110_0<=RULE_STRING)||LA110_0==27||LA110_0==31||(LA110_0>=34 && LA110_0<=35)||LA110_0==40||(LA110_0>=45 && LA110_0<=50)||LA110_0==53||(LA110_0>=57 && LA110_0<=58)||LA110_0==61||LA110_0==63||LA110_0==65||(LA110_0>=69 && LA110_0<=77)||LA110_0==79||LA110_0==86||LA110_0==88) ) {
+ alt110=1;
+ }
+ switch (alt110) {
+ case 1 :
+ // InternalOXtype.g:13062:3: rule__XConstructorCall__Alternatives_4_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Alternatives_4_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_4__1__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_4__2"
+ // InternalOXtype.g:13070:1: rule__XConstructorCall__Group_4__2 : rule__XConstructorCall__Group_4__2__Impl ;
+ public final void rule__XConstructorCall__Group_4__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13074:1: ( rule__XConstructorCall__Group_4__2__Impl )
+ // InternalOXtype.g:13075:2: rule__XConstructorCall__Group_4__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_4__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_4__2"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_4__2__Impl"
+ // InternalOXtype.g:13081:1: rule__XConstructorCall__Group_4__2__Impl : ( ')' ) ;
+ public final void rule__XConstructorCall__Group_4__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13085:1: ( ( ')' ) )
+ // InternalOXtype.g:13086:1: ( ')' )
+ {
+ // InternalOXtype.g:13086:1: ( ')' )
+ // InternalOXtype.g:13087:2: ')'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2());
+ }
+ match(input,54,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_4__2__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_4_1_1__0"
+ // InternalOXtype.g:13097:1: rule__XConstructorCall__Group_4_1_1__0 : rule__XConstructorCall__Group_4_1_1__0__Impl rule__XConstructorCall__Group_4_1_1__1 ;
+ public final void rule__XConstructorCall__Group_4_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13101:1: ( rule__XConstructorCall__Group_4_1_1__0__Impl rule__XConstructorCall__Group_4_1_1__1 )
+ // InternalOXtype.g:13102:2: rule__XConstructorCall__Group_4_1_1__0__Impl rule__XConstructorCall__Group_4_1_1__1
+ {
+ pushFollow(FOLLOW_13);
+ rule__XConstructorCall__Group_4_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_4_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_4_1_1__0"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_4_1_1__0__Impl"
+ // InternalOXtype.g:13109:1: rule__XConstructorCall__Group_4_1_1__0__Impl : ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) ) ;
+ public final void rule__XConstructorCall__Group_4_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13113:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) ) )
+ // InternalOXtype.g:13114:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) )
+ {
+ // InternalOXtype.g:13114:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) )
+ // InternalOXtype.g:13115:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0());
+ }
+ // InternalOXtype.g:13116:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 )
+ // InternalOXtype.g:13116:3: rule__XConstructorCall__ArgumentsAssignment_4_1_1_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__ArgumentsAssignment_4_1_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_4_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_4_1_1__1"
+ // InternalOXtype.g:13124:1: rule__XConstructorCall__Group_4_1_1__1 : rule__XConstructorCall__Group_4_1_1__1__Impl ;
+ public final void rule__XConstructorCall__Group_4_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13128:1: ( rule__XConstructorCall__Group_4_1_1__1__Impl )
+ // InternalOXtype.g:13129:2: rule__XConstructorCall__Group_4_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_4_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_4_1_1__1"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_4_1_1__1__Impl"
+ // InternalOXtype.g:13135:1: rule__XConstructorCall__Group_4_1_1__1__Impl : ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* ) ;
+ public final void rule__XConstructorCall__Group_4_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13139:1: ( ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* ) )
+ // InternalOXtype.g:13140:1: ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* )
+ {
+ // InternalOXtype.g:13140:1: ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* )
+ // InternalOXtype.g:13141:2: ( rule__XConstructorCall__Group_4_1_1_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1());
+ }
+ // InternalOXtype.g:13142:2: ( rule__XConstructorCall__Group_4_1_1_1__0 )*
+ loop111:
+ do {
+ int alt111=2;
+ int LA111_0 = input.LA(1);
+
+ if ( (LA111_0==55) ) {
+ alt111=1;
+ }
+
+
+ switch (alt111) {
+ case 1 :
+ // InternalOXtype.g:13142:3: rule__XConstructorCall__Group_4_1_1_1__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XConstructorCall__Group_4_1_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop111;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_4_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__0"
+ // InternalOXtype.g:13151:1: rule__XConstructorCall__Group_4_1_1_1__0 : rule__XConstructorCall__Group_4_1_1_1__0__Impl rule__XConstructorCall__Group_4_1_1_1__1 ;
+ public final void rule__XConstructorCall__Group_4_1_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13155:1: ( rule__XConstructorCall__Group_4_1_1_1__0__Impl rule__XConstructorCall__Group_4_1_1_1__1 )
+ // InternalOXtype.g:13156:2: rule__XConstructorCall__Group_4_1_1_1__0__Impl rule__XConstructorCall__Group_4_1_1_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XConstructorCall__Group_4_1_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_4_1_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__0"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__0__Impl"
+ // InternalOXtype.g:13163:1: rule__XConstructorCall__Group_4_1_1_1__0__Impl : ( ',' ) ;
+ public final void rule__XConstructorCall__Group_4_1_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13167:1: ( ( ',' ) )
+ // InternalOXtype.g:13168:1: ( ',' )
+ {
+ // InternalOXtype.g:13168:1: ( ',' )
+ // InternalOXtype.g:13169:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__1"
+ // InternalOXtype.g:13178:1: rule__XConstructorCall__Group_4_1_1_1__1 : rule__XConstructorCall__Group_4_1_1_1__1__Impl ;
+ public final void rule__XConstructorCall__Group_4_1_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13182:1: ( rule__XConstructorCall__Group_4_1_1_1__1__Impl )
+ // InternalOXtype.g:13183:2: rule__XConstructorCall__Group_4_1_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_4_1_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__1"
+
+
+ // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__1__Impl"
+ // InternalOXtype.g:13189:1: rule__XConstructorCall__Group_4_1_1_1__1__Impl : ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) ) ;
+ public final void rule__XConstructorCall__Group_4_1_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13193:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) ) )
+ // InternalOXtype.g:13194:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) )
+ {
+ // InternalOXtype.g:13194:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) )
+ // InternalOXtype.g:13195:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1());
+ }
+ // InternalOXtype.g:13196:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 )
+ // InternalOXtype.g:13196:3: rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__XBooleanLiteral__Group__0"
+ // InternalOXtype.g:13205:1: rule__XBooleanLiteral__Group__0 : rule__XBooleanLiteral__Group__0__Impl rule__XBooleanLiteral__Group__1 ;
+ public final void rule__XBooleanLiteral__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13209:1: ( rule__XBooleanLiteral__Group__0__Impl rule__XBooleanLiteral__Group__1 )
+ // InternalOXtype.g:13210:2: rule__XBooleanLiteral__Group__0__Impl rule__XBooleanLiteral__Group__1
+ {
+ pushFollow(FOLLOW_80);
+ rule__XBooleanLiteral__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XBooleanLiteral__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBooleanLiteral__Group__0"
+
+
+ // $ANTLR start "rule__XBooleanLiteral__Group__0__Impl"
+ // InternalOXtype.g:13217:1: rule__XBooleanLiteral__Group__0__Impl : ( () ) ;
+ public final void rule__XBooleanLiteral__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13221:1: ( ( () ) )
+ // InternalOXtype.g:13222:1: ( () )
+ {
+ // InternalOXtype.g:13222:1: ( () )
+ // InternalOXtype.g:13223:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0());
+ }
+ // InternalOXtype.g:13224:2: ()
+ // InternalOXtype.g:13224:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBooleanLiteral__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XBooleanLiteral__Group__1"
+ // InternalOXtype.g:13232:1: rule__XBooleanLiteral__Group__1 : rule__XBooleanLiteral__Group__1__Impl ;
+ public final void rule__XBooleanLiteral__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13236:1: ( rule__XBooleanLiteral__Group__1__Impl )
+ // InternalOXtype.g:13237:2: rule__XBooleanLiteral__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBooleanLiteral__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBooleanLiteral__Group__1"
+
+
+ // $ANTLR start "rule__XBooleanLiteral__Group__1__Impl"
+ // InternalOXtype.g:13243:1: rule__XBooleanLiteral__Group__1__Impl : ( ( rule__XBooleanLiteral__Alternatives_1 ) ) ;
+ public final void rule__XBooleanLiteral__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13247:1: ( ( ( rule__XBooleanLiteral__Alternatives_1 ) ) )
+ // InternalOXtype.g:13248:1: ( ( rule__XBooleanLiteral__Alternatives_1 ) )
+ {
+ // InternalOXtype.g:13248:1: ( ( rule__XBooleanLiteral__Alternatives_1 ) )
+ // InternalOXtype.g:13249:2: ( rule__XBooleanLiteral__Alternatives_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1());
+ }
+ // InternalOXtype.g:13250:2: ( rule__XBooleanLiteral__Alternatives_1 )
+ // InternalOXtype.g:13250:3: rule__XBooleanLiteral__Alternatives_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XBooleanLiteral__Alternatives_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBooleanLiteral__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XNullLiteral__Group__0"
+ // InternalOXtype.g:13259:1: rule__XNullLiteral__Group__0 : rule__XNullLiteral__Group__0__Impl rule__XNullLiteral__Group__1 ;
+ public final void rule__XNullLiteral__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13263:1: ( rule__XNullLiteral__Group__0__Impl rule__XNullLiteral__Group__1 )
+ // InternalOXtype.g:13264:2: rule__XNullLiteral__Group__0__Impl rule__XNullLiteral__Group__1
+ {
+ pushFollow(FOLLOW_81);
+ rule__XNullLiteral__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XNullLiteral__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XNullLiteral__Group__0"
+
+
+ // $ANTLR start "rule__XNullLiteral__Group__0__Impl"
+ // InternalOXtype.g:13271:1: rule__XNullLiteral__Group__0__Impl : ( () ) ;
+ public final void rule__XNullLiteral__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13275:1: ( ( () ) )
+ // InternalOXtype.g:13276:1: ( () )
+ {
+ // InternalOXtype.g:13276:1: ( () )
+ // InternalOXtype.g:13277:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0());
+ }
+ // InternalOXtype.g:13278:2: ()
+ // InternalOXtype.g:13278:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XNullLiteral__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XNullLiteral__Group__1"
+ // InternalOXtype.g:13286:1: rule__XNullLiteral__Group__1 : rule__XNullLiteral__Group__1__Impl ;
+ public final void rule__XNullLiteral__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13290:1: ( rule__XNullLiteral__Group__1__Impl )
+ // InternalOXtype.g:13291:2: rule__XNullLiteral__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XNullLiteral__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XNullLiteral__Group__1"
+
+
+ // $ANTLR start "rule__XNullLiteral__Group__1__Impl"
+ // InternalOXtype.g:13297:1: rule__XNullLiteral__Group__1__Impl : ( 'null' ) ;
+ public final void rule__XNullLiteral__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13301:1: ( ( 'null' ) )
+ // InternalOXtype.g:13302:1: ( 'null' )
+ {
+ // InternalOXtype.g:13302:1: ( 'null' )
+ // InternalOXtype.g:13303:2: 'null'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXNullLiteralAccess().getNullKeyword_1());
+ }
+ match(input,73,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXNullLiteralAccess().getNullKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XNullLiteral__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XNumberLiteral__Group__0"
+ // InternalOXtype.g:13313:1: rule__XNumberLiteral__Group__0 : rule__XNumberLiteral__Group__0__Impl rule__XNumberLiteral__Group__1 ;
+ public final void rule__XNumberLiteral__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13317:1: ( rule__XNumberLiteral__Group__0__Impl rule__XNumberLiteral__Group__1 )
+ // InternalOXtype.g:13318:2: rule__XNumberLiteral__Group__0__Impl rule__XNumberLiteral__Group__1
+ {
+ pushFollow(FOLLOW_82);
+ rule__XNumberLiteral__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XNumberLiteral__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XNumberLiteral__Group__0"
+
+
+ // $ANTLR start "rule__XNumberLiteral__Group__0__Impl"
+ // InternalOXtype.g:13325:1: rule__XNumberLiteral__Group__0__Impl : ( () ) ;
+ public final void rule__XNumberLiteral__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13329:1: ( ( () ) )
+ // InternalOXtype.g:13330:1: ( () )
+ {
+ // InternalOXtype.g:13330:1: ( () )
+ // InternalOXtype.g:13331:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0());
+ }
+ // InternalOXtype.g:13332:2: ()
+ // InternalOXtype.g:13332:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XNumberLiteral__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XNumberLiteral__Group__1"
+ // InternalOXtype.g:13340:1: rule__XNumberLiteral__Group__1 : rule__XNumberLiteral__Group__1__Impl ;
+ public final void rule__XNumberLiteral__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13344:1: ( rule__XNumberLiteral__Group__1__Impl )
+ // InternalOXtype.g:13345:2: rule__XNumberLiteral__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XNumberLiteral__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XNumberLiteral__Group__1"
+
+
+ // $ANTLR start "rule__XNumberLiteral__Group__1__Impl"
+ // InternalOXtype.g:13351:1: rule__XNumberLiteral__Group__1__Impl : ( ( rule__XNumberLiteral__ValueAssignment_1 ) ) ;
+ public final void rule__XNumberLiteral__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13355:1: ( ( ( rule__XNumberLiteral__ValueAssignment_1 ) ) )
+ // InternalOXtype.g:13356:1: ( ( rule__XNumberLiteral__ValueAssignment_1 ) )
+ {
+ // InternalOXtype.g:13356:1: ( ( rule__XNumberLiteral__ValueAssignment_1 ) )
+ // InternalOXtype.g:13357:2: ( rule__XNumberLiteral__ValueAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1());
+ }
+ // InternalOXtype.g:13358:2: ( rule__XNumberLiteral__ValueAssignment_1 )
+ // InternalOXtype.g:13358:3: rule__XNumberLiteral__ValueAssignment_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XNumberLiteral__ValueAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XNumberLiteral__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XStringLiteral__Group__0"
+ // InternalOXtype.g:13367:1: rule__XStringLiteral__Group__0 : rule__XStringLiteral__Group__0__Impl rule__XStringLiteral__Group__1 ;
+ public final void rule__XStringLiteral__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13371:1: ( rule__XStringLiteral__Group__0__Impl rule__XStringLiteral__Group__1 )
+ // InternalOXtype.g:13372:2: rule__XStringLiteral__Group__0__Impl rule__XStringLiteral__Group__1
+ {
+ pushFollow(FOLLOW_83);
+ rule__XStringLiteral__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XStringLiteral__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XStringLiteral__Group__0"
+
+
+ // $ANTLR start "rule__XStringLiteral__Group__0__Impl"
+ // InternalOXtype.g:13379:1: rule__XStringLiteral__Group__0__Impl : ( () ) ;
+ public final void rule__XStringLiteral__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13383:1: ( ( () ) )
+ // InternalOXtype.g:13384:1: ( () )
+ {
+ // InternalOXtype.g:13384:1: ( () )
+ // InternalOXtype.g:13385:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0());
+ }
+ // InternalOXtype.g:13386:2: ()
+ // InternalOXtype.g:13386:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XStringLiteral__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XStringLiteral__Group__1"
+ // InternalOXtype.g:13394:1: rule__XStringLiteral__Group__1 : rule__XStringLiteral__Group__1__Impl ;
+ public final void rule__XStringLiteral__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13398:1: ( rule__XStringLiteral__Group__1__Impl )
+ // InternalOXtype.g:13399:2: rule__XStringLiteral__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XStringLiteral__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XStringLiteral__Group__1"
+
+
+ // $ANTLR start "rule__XStringLiteral__Group__1__Impl"
+ // InternalOXtype.g:13405:1: rule__XStringLiteral__Group__1__Impl : ( ( rule__XStringLiteral__ValueAssignment_1 ) ) ;
+ public final void rule__XStringLiteral__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13409:1: ( ( ( rule__XStringLiteral__ValueAssignment_1 ) ) )
+ // InternalOXtype.g:13410:1: ( ( rule__XStringLiteral__ValueAssignment_1 ) )
+ {
+ // InternalOXtype.g:13410:1: ( ( rule__XStringLiteral__ValueAssignment_1 ) )
+ // InternalOXtype.g:13411:2: ( rule__XStringLiteral__ValueAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXStringLiteralAccess().getValueAssignment_1());
+ }
+ // InternalOXtype.g:13412:2: ( rule__XStringLiteral__ValueAssignment_1 )
+ // InternalOXtype.g:13412:3: rule__XStringLiteral__ValueAssignment_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XStringLiteral__ValueAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXStringLiteralAccess().getValueAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XStringLiteral__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XTypeLiteral__Group__0"
+ // InternalOXtype.g:13421:1: rule__XTypeLiteral__Group__0 : rule__XTypeLiteral__Group__0__Impl rule__XTypeLiteral__Group__1 ;
+ public final void rule__XTypeLiteral__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13425:1: ( rule__XTypeLiteral__Group__0__Impl rule__XTypeLiteral__Group__1 )
+ // InternalOXtype.g:13426:2: rule__XTypeLiteral__Group__0__Impl rule__XTypeLiteral__Group__1
+ {
+ pushFollow(FOLLOW_84);
+ rule__XTypeLiteral__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XTypeLiteral__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTypeLiteral__Group__0"
+
+
+ // $ANTLR start "rule__XTypeLiteral__Group__0__Impl"
+ // InternalOXtype.g:13433:1: rule__XTypeLiteral__Group__0__Impl : ( () ) ;
+ public final void rule__XTypeLiteral__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13437:1: ( ( () ) )
+ // InternalOXtype.g:13438:1: ( () )
+ {
+ // InternalOXtype.g:13438:1: ( () )
+ // InternalOXtype.g:13439:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0());
+ }
+ // InternalOXtype.g:13440:2: ()
+ // InternalOXtype.g:13440:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTypeLiteral__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XTypeLiteral__Group__1"
+ // InternalOXtype.g:13448:1: rule__XTypeLiteral__Group__1 : rule__XTypeLiteral__Group__1__Impl rule__XTypeLiteral__Group__2 ;
+ public final void rule__XTypeLiteral__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13452:1: ( rule__XTypeLiteral__Group__1__Impl rule__XTypeLiteral__Group__2 )
+ // InternalOXtype.g:13453:2: rule__XTypeLiteral__Group__1__Impl rule__XTypeLiteral__Group__2
+ {
+ pushFollow(FOLLOW_11);
+ rule__XTypeLiteral__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XTypeLiteral__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTypeLiteral__Group__1"
+
+
+ // $ANTLR start "rule__XTypeLiteral__Group__1__Impl"
+ // InternalOXtype.g:13460:1: rule__XTypeLiteral__Group__1__Impl : ( 'typeof' ) ;
+ public final void rule__XTypeLiteral__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13464:1: ( ( 'typeof' ) )
+ // InternalOXtype.g:13465:1: ( 'typeof' )
+ {
+ // InternalOXtype.g:13465:1: ( 'typeof' )
+ // InternalOXtype.g:13466:2: 'typeof'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1());
+ }
+ match(input,74,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTypeLiteral__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XTypeLiteral__Group__2"
+ // InternalOXtype.g:13475:1: rule__XTypeLiteral__Group__2 : rule__XTypeLiteral__Group__2__Impl rule__XTypeLiteral__Group__3 ;
+ public final void rule__XTypeLiteral__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13479:1: ( rule__XTypeLiteral__Group__2__Impl rule__XTypeLiteral__Group__3 )
+ // InternalOXtype.g:13480:2: rule__XTypeLiteral__Group__2__Impl rule__XTypeLiteral__Group__3
+ {
+ pushFollow(FOLLOW_9);
+ rule__XTypeLiteral__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XTypeLiteral__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTypeLiteral__Group__2"
+
+
+ // $ANTLR start "rule__XTypeLiteral__Group__2__Impl"
+ // InternalOXtype.g:13487:1: rule__XTypeLiteral__Group__2__Impl : ( '(' ) ;
+ public final void rule__XTypeLiteral__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13491:1: ( ( '(' ) )
+ // InternalOXtype.g:13492:1: ( '(' )
+ {
+ // InternalOXtype.g:13492:1: ( '(' )
+ // InternalOXtype.g:13493:2: '('
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2());
+ }
+ match(input,53,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTypeLiteral__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XTypeLiteral__Group__3"
+ // InternalOXtype.g:13502:1: rule__XTypeLiteral__Group__3 : rule__XTypeLiteral__Group__3__Impl rule__XTypeLiteral__Group__4 ;
+ public final void rule__XTypeLiteral__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13506:1: ( rule__XTypeLiteral__Group__3__Impl rule__XTypeLiteral__Group__4 )
+ // InternalOXtype.g:13507:2: rule__XTypeLiteral__Group__3__Impl rule__XTypeLiteral__Group__4
+ {
+ pushFollow(FOLLOW_85);
+ rule__XTypeLiteral__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XTypeLiteral__Group__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTypeLiteral__Group__3"
+
+
+ // $ANTLR start "rule__XTypeLiteral__Group__3__Impl"
+ // InternalOXtype.g:13514:1: rule__XTypeLiteral__Group__3__Impl : ( ( rule__XTypeLiteral__TypeAssignment_3 ) ) ;
+ public final void rule__XTypeLiteral__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13518:1: ( ( ( rule__XTypeLiteral__TypeAssignment_3 ) ) )
+ // InternalOXtype.g:13519:1: ( ( rule__XTypeLiteral__TypeAssignment_3 ) )
+ {
+ // InternalOXtype.g:13519:1: ( ( rule__XTypeLiteral__TypeAssignment_3 ) )
+ // InternalOXtype.g:13520:2: ( rule__XTypeLiteral__TypeAssignment_3 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3());
+ }
+ // InternalOXtype.g:13521:2: ( rule__XTypeLiteral__TypeAssignment_3 )
+ // InternalOXtype.g:13521:3: rule__XTypeLiteral__TypeAssignment_3
+ {
+ pushFollow(FOLLOW_2);
+ rule__XTypeLiteral__TypeAssignment_3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTypeLiteral__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XTypeLiteral__Group__4"
+ // InternalOXtype.g:13529:1: rule__XTypeLiteral__Group__4 : rule__XTypeLiteral__Group__4__Impl rule__XTypeLiteral__Group__5 ;
+ public final void rule__XTypeLiteral__Group__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13533:1: ( rule__XTypeLiteral__Group__4__Impl rule__XTypeLiteral__Group__5 )
+ // InternalOXtype.g:13534:2: rule__XTypeLiteral__Group__4__Impl rule__XTypeLiteral__Group__5
+ {
+ pushFollow(FOLLOW_85);
+ rule__XTypeLiteral__Group__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XTypeLiteral__Group__5();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTypeLiteral__Group__4"
+
+
+ // $ANTLR start "rule__XTypeLiteral__Group__4__Impl"
+ // InternalOXtype.g:13541:1: rule__XTypeLiteral__Group__4__Impl : ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* ) ;
+ public final void rule__XTypeLiteral__Group__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13545:1: ( ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* ) )
+ // InternalOXtype.g:13546:1: ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* )
+ {
+ // InternalOXtype.g:13546:1: ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* )
+ // InternalOXtype.g:13547:2: ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4());
+ }
+ // InternalOXtype.g:13548:2: ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )*
+ loop112:
+ do {
+ int alt112=2;
+ int LA112_0 = input.LA(1);
+
+ if ( (LA112_0==58) ) {
+ alt112=1;
+ }
+
+
+ switch (alt112) {
+ case 1 :
+ // InternalOXtype.g:13548:3: rule__XTypeLiteral__ArrayDimensionsAssignment_4
+ {
+ pushFollow(FOLLOW_86);
+ rule__XTypeLiteral__ArrayDimensionsAssignment_4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop112;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTypeLiteral__Group__4__Impl"
+
+
+ // $ANTLR start "rule__XTypeLiteral__Group__5"
+ // InternalOXtype.g:13556:1: rule__XTypeLiteral__Group__5 : rule__XTypeLiteral__Group__5__Impl ;
+ public final void rule__XTypeLiteral__Group__5() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13560:1: ( rule__XTypeLiteral__Group__5__Impl )
+ // InternalOXtype.g:13561:2: rule__XTypeLiteral__Group__5__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XTypeLiteral__Group__5__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTypeLiteral__Group__5"
+
+
+ // $ANTLR start "rule__XTypeLiteral__Group__5__Impl"
+ // InternalOXtype.g:13567:1: rule__XTypeLiteral__Group__5__Impl : ( ')' ) ;
+ public final void rule__XTypeLiteral__Group__5__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13571:1: ( ( ')' ) )
+ // InternalOXtype.g:13572:1: ( ')' )
+ {
+ // InternalOXtype.g:13572:1: ( ')' )
+ // InternalOXtype.g:13573:2: ')'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5());
+ }
+ match(input,54,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTypeLiteral__Group__5__Impl"
+
+
+ // $ANTLR start "rule__XThrowExpression__Group__0"
+ // InternalOXtype.g:13583:1: rule__XThrowExpression__Group__0 : rule__XThrowExpression__Group__0__Impl rule__XThrowExpression__Group__1 ;
+ public final void rule__XThrowExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13587:1: ( rule__XThrowExpression__Group__0__Impl rule__XThrowExpression__Group__1 )
+ // InternalOXtype.g:13588:2: rule__XThrowExpression__Group__0__Impl rule__XThrowExpression__Group__1
+ {
+ pushFollow(FOLLOW_87);
+ rule__XThrowExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XThrowExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XThrowExpression__Group__0"
+
+
+ // $ANTLR start "rule__XThrowExpression__Group__0__Impl"
+ // InternalOXtype.g:13595:1: rule__XThrowExpression__Group__0__Impl : ( () ) ;
+ public final void rule__XThrowExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13599:1: ( ( () ) )
+ // InternalOXtype.g:13600:1: ( () )
+ {
+ // InternalOXtype.g:13600:1: ( () )
+ // InternalOXtype.g:13601:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0());
+ }
+ // InternalOXtype.g:13602:2: ()
+ // InternalOXtype.g:13602:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XThrowExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XThrowExpression__Group__1"
+ // InternalOXtype.g:13610:1: rule__XThrowExpression__Group__1 : rule__XThrowExpression__Group__1__Impl rule__XThrowExpression__Group__2 ;
+ public final void rule__XThrowExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13614:1: ( rule__XThrowExpression__Group__1__Impl rule__XThrowExpression__Group__2 )
+ // InternalOXtype.g:13615:2: rule__XThrowExpression__Group__1__Impl rule__XThrowExpression__Group__2
+ {
+ pushFollow(FOLLOW_15);
+ rule__XThrowExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XThrowExpression__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XThrowExpression__Group__1"
+
+
+ // $ANTLR start "rule__XThrowExpression__Group__1__Impl"
+ // InternalOXtype.g:13622:1: rule__XThrowExpression__Group__1__Impl : ( 'throw' ) ;
+ public final void rule__XThrowExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13626:1: ( ( 'throw' ) )
+ // InternalOXtype.g:13627:1: ( 'throw' )
+ {
+ // InternalOXtype.g:13627:1: ( 'throw' )
+ // InternalOXtype.g:13628:2: 'throw'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1());
+ }
+ match(input,75,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XThrowExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XThrowExpression__Group__2"
+ // InternalOXtype.g:13637:1: rule__XThrowExpression__Group__2 : rule__XThrowExpression__Group__2__Impl ;
+ public final void rule__XThrowExpression__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13641:1: ( rule__XThrowExpression__Group__2__Impl )
+ // InternalOXtype.g:13642:2: rule__XThrowExpression__Group__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XThrowExpression__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XThrowExpression__Group__2"
+
+
+ // $ANTLR start "rule__XThrowExpression__Group__2__Impl"
+ // InternalOXtype.g:13648:1: rule__XThrowExpression__Group__2__Impl : ( ( rule__XThrowExpression__ExpressionAssignment_2 ) ) ;
+ public final void rule__XThrowExpression__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13652:1: ( ( ( rule__XThrowExpression__ExpressionAssignment_2 ) ) )
+ // InternalOXtype.g:13653:1: ( ( rule__XThrowExpression__ExpressionAssignment_2 ) )
+ {
+ // InternalOXtype.g:13653:1: ( ( rule__XThrowExpression__ExpressionAssignment_2 ) )
+ // InternalOXtype.g:13654:2: ( rule__XThrowExpression__ExpressionAssignment_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2());
+ }
+ // InternalOXtype.g:13655:2: ( rule__XThrowExpression__ExpressionAssignment_2 )
+ // InternalOXtype.g:13655:3: rule__XThrowExpression__ExpressionAssignment_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XThrowExpression__ExpressionAssignment_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XThrowExpression__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XReturnExpression__Group__0"
+ // InternalOXtype.g:13664:1: rule__XReturnExpression__Group__0 : rule__XReturnExpression__Group__0__Impl rule__XReturnExpression__Group__1 ;
+ public final void rule__XReturnExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13668:1: ( rule__XReturnExpression__Group__0__Impl rule__XReturnExpression__Group__1 )
+ // InternalOXtype.g:13669:2: rule__XReturnExpression__Group__0__Impl rule__XReturnExpression__Group__1
+ {
+ pushFollow(FOLLOW_88);
+ rule__XReturnExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XReturnExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XReturnExpression__Group__0"
+
+
+ // $ANTLR start "rule__XReturnExpression__Group__0__Impl"
+ // InternalOXtype.g:13676:1: rule__XReturnExpression__Group__0__Impl : ( () ) ;
+ public final void rule__XReturnExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13680:1: ( ( () ) )
+ // InternalOXtype.g:13681:1: ( () )
+ {
+ // InternalOXtype.g:13681:1: ( () )
+ // InternalOXtype.g:13682:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0());
+ }
+ // InternalOXtype.g:13683:2: ()
+ // InternalOXtype.g:13683:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XReturnExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XReturnExpression__Group__1"
+ // InternalOXtype.g:13691:1: rule__XReturnExpression__Group__1 : rule__XReturnExpression__Group__1__Impl rule__XReturnExpression__Group__2 ;
+ public final void rule__XReturnExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13695:1: ( rule__XReturnExpression__Group__1__Impl rule__XReturnExpression__Group__2 )
+ // InternalOXtype.g:13696:2: rule__XReturnExpression__Group__1__Impl rule__XReturnExpression__Group__2
+ {
+ pushFollow(FOLLOW_15);
+ rule__XReturnExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XReturnExpression__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XReturnExpression__Group__1"
+
+
+ // $ANTLR start "rule__XReturnExpression__Group__1__Impl"
+ // InternalOXtype.g:13703:1: rule__XReturnExpression__Group__1__Impl : ( 'return' ) ;
+ public final void rule__XReturnExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13707:1: ( ( 'return' ) )
+ // InternalOXtype.g:13708:1: ( 'return' )
+ {
+ // InternalOXtype.g:13708:1: ( 'return' )
+ // InternalOXtype.g:13709:2: 'return'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1());
+ }
+ match(input,76,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XReturnExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XReturnExpression__Group__2"
+ // InternalOXtype.g:13718:1: rule__XReturnExpression__Group__2 : rule__XReturnExpression__Group__2__Impl ;
+ public final void rule__XReturnExpression__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13722:1: ( rule__XReturnExpression__Group__2__Impl )
+ // InternalOXtype.g:13723:2: rule__XReturnExpression__Group__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XReturnExpression__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XReturnExpression__Group__2"
+
+
+ // $ANTLR start "rule__XReturnExpression__Group__2__Impl"
+ // InternalOXtype.g:13729:1: rule__XReturnExpression__Group__2__Impl : ( ( rule__XReturnExpression__ExpressionAssignment_2 )? ) ;
+ public final void rule__XReturnExpression__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13733:1: ( ( ( rule__XReturnExpression__ExpressionAssignment_2 )? ) )
+ // InternalOXtype.g:13734:1: ( ( rule__XReturnExpression__ExpressionAssignment_2 )? )
+ {
+ // InternalOXtype.g:13734:1: ( ( rule__XReturnExpression__ExpressionAssignment_2 )? )
+ // InternalOXtype.g:13735:2: ( rule__XReturnExpression__ExpressionAssignment_2 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2());
+ }
+ // InternalOXtype.g:13736:2: ( rule__XReturnExpression__ExpressionAssignment_2 )?
+ int alt113=2;
+ alt113 = dfa113.predict(input);
+ switch (alt113) {
+ case 1 :
+ // InternalOXtype.g:13736:3: rule__XReturnExpression__ExpressionAssignment_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XReturnExpression__ExpressionAssignment_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XReturnExpression__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group__0"
+ // InternalOXtype.g:13745:1: rule__XTryCatchFinallyExpression__Group__0 : rule__XTryCatchFinallyExpression__Group__0__Impl rule__XTryCatchFinallyExpression__Group__1 ;
+ public final void rule__XTryCatchFinallyExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13749:1: ( rule__XTryCatchFinallyExpression__Group__0__Impl rule__XTryCatchFinallyExpression__Group__1 )
+ // InternalOXtype.g:13750:2: rule__XTryCatchFinallyExpression__Group__0__Impl rule__XTryCatchFinallyExpression__Group__1
+ {
+ pushFollow(FOLLOW_89);
+ rule__XTryCatchFinallyExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group__0"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group__0__Impl"
+ // InternalOXtype.g:13757:1: rule__XTryCatchFinallyExpression__Group__0__Impl : ( () ) ;
+ public final void rule__XTryCatchFinallyExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13761:1: ( ( () ) )
+ // InternalOXtype.g:13762:1: ( () )
+ {
+ // InternalOXtype.g:13762:1: ( () )
+ // InternalOXtype.g:13763:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0());
+ }
+ // InternalOXtype.g:13764:2: ()
+ // InternalOXtype.g:13764:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group__1"
+ // InternalOXtype.g:13772:1: rule__XTryCatchFinallyExpression__Group__1 : rule__XTryCatchFinallyExpression__Group__1__Impl rule__XTryCatchFinallyExpression__Group__2 ;
+ public final void rule__XTryCatchFinallyExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13776:1: ( rule__XTryCatchFinallyExpression__Group__1__Impl rule__XTryCatchFinallyExpression__Group__2 )
+ // InternalOXtype.g:13777:2: rule__XTryCatchFinallyExpression__Group__1__Impl rule__XTryCatchFinallyExpression__Group__2
+ {
+ pushFollow(FOLLOW_15);
+ rule__XTryCatchFinallyExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group__1"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group__1__Impl"
+ // InternalOXtype.g:13784:1: rule__XTryCatchFinallyExpression__Group__1__Impl : ( 'try' ) ;
+ public final void rule__XTryCatchFinallyExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13788:1: ( ( 'try' ) )
+ // InternalOXtype.g:13789:1: ( 'try' )
+ {
+ // InternalOXtype.g:13789:1: ( 'try' )
+ // InternalOXtype.g:13790:2: 'try'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1());
+ }
+ match(input,77,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group__2"
+ // InternalOXtype.g:13799:1: rule__XTryCatchFinallyExpression__Group__2 : rule__XTryCatchFinallyExpression__Group__2__Impl rule__XTryCatchFinallyExpression__Group__3 ;
+ public final void rule__XTryCatchFinallyExpression__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13803:1: ( rule__XTryCatchFinallyExpression__Group__2__Impl rule__XTryCatchFinallyExpression__Group__3 )
+ // InternalOXtype.g:13804:2: rule__XTryCatchFinallyExpression__Group__2__Impl rule__XTryCatchFinallyExpression__Group__3
+ {
+ pushFollow(FOLLOW_90);
+ rule__XTryCatchFinallyExpression__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group__2"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group__2__Impl"
+ // InternalOXtype.g:13811:1: rule__XTryCatchFinallyExpression__Group__2__Impl : ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) ) ;
+ public final void rule__XTryCatchFinallyExpression__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13815:1: ( ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) ) )
+ // InternalOXtype.g:13816:1: ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) )
+ {
+ // InternalOXtype.g:13816:1: ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) )
+ // InternalOXtype.g:13817:2: ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2());
+ }
+ // InternalOXtype.g:13818:2: ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 )
+ // InternalOXtype.g:13818:3: rule__XTryCatchFinallyExpression__ExpressionAssignment_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__ExpressionAssignment_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group__3"
+ // InternalOXtype.g:13826:1: rule__XTryCatchFinallyExpression__Group__3 : rule__XTryCatchFinallyExpression__Group__3__Impl ;
+ public final void rule__XTryCatchFinallyExpression__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13830:1: ( rule__XTryCatchFinallyExpression__Group__3__Impl )
+ // InternalOXtype.g:13831:2: rule__XTryCatchFinallyExpression__Group__3__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group__3"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group__3__Impl"
+ // InternalOXtype.g:13837:1: rule__XTryCatchFinallyExpression__Group__3__Impl : ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) ) ;
+ public final void rule__XTryCatchFinallyExpression__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13841:1: ( ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) ) )
+ // InternalOXtype.g:13842:1: ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) )
+ {
+ // InternalOXtype.g:13842:1: ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) )
+ // InternalOXtype.g:13843:2: ( rule__XTryCatchFinallyExpression__Alternatives_3 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3());
+ }
+ // InternalOXtype.g:13844:2: ( rule__XTryCatchFinallyExpression__Alternatives_3 )
+ // InternalOXtype.g:13844:3: rule__XTryCatchFinallyExpression__Alternatives_3
+ {
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__Alternatives_3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__0"
+ // InternalOXtype.g:13853:1: rule__XTryCatchFinallyExpression__Group_3_0__0 : rule__XTryCatchFinallyExpression__Group_3_0__0__Impl rule__XTryCatchFinallyExpression__Group_3_0__1 ;
+ public final void rule__XTryCatchFinallyExpression__Group_3_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13857:1: ( rule__XTryCatchFinallyExpression__Group_3_0__0__Impl rule__XTryCatchFinallyExpression__Group_3_0__1 )
+ // InternalOXtype.g:13858:2: rule__XTryCatchFinallyExpression__Group_3_0__0__Impl rule__XTryCatchFinallyExpression__Group_3_0__1
+ {
+ pushFollow(FOLLOW_91);
+ rule__XTryCatchFinallyExpression__Group_3_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__Group_3_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__0"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__0__Impl"
+ // InternalOXtype.g:13865:1: rule__XTryCatchFinallyExpression__Group_3_0__0__Impl : ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) ) ;
+ public final void rule__XTryCatchFinallyExpression__Group_3_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13869:1: ( ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) ) )
+ // InternalOXtype.g:13870:1: ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) )
+ {
+ // InternalOXtype.g:13870:1: ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) )
+ // InternalOXtype.g:13871:2: ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* )
+ {
+ // InternalOXtype.g:13871:2: ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) )
+ // InternalOXtype.g:13872:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0());
+ }
+ // InternalOXtype.g:13873:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )
+ // InternalOXtype.g:13873:4: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0
+ {
+ pushFollow(FOLLOW_92);
+ rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0());
+ }
+
+ }
+
+ // InternalOXtype.g:13876:2: ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* )
+ // InternalOXtype.g:13877:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0());
+ }
+ // InternalOXtype.g:13878:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )*
+ loop114:
+ do {
+ int alt114=2;
+ int LA114_0 = input.LA(1);
+
+ if ( (LA114_0==80) ) {
+ int LA114_2 = input.LA(2);
+
+ if ( (synpred158_InternalOXtype()) ) {
+ alt114=1;
+ }
+
+
+ }
+
+
+ switch (alt114) {
+ case 1 :
+ // InternalOXtype.g:13878:4: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0
+ {
+ pushFollow(FOLLOW_92);
+ rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop114;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0());
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__0__Impl"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__1"
+ // InternalOXtype.g:13887:1: rule__XTryCatchFinallyExpression__Group_3_0__1 : rule__XTryCatchFinallyExpression__Group_3_0__1__Impl ;
+ public final void rule__XTryCatchFinallyExpression__Group_3_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13891:1: ( rule__XTryCatchFinallyExpression__Group_3_0__1__Impl )
+ // InternalOXtype.g:13892:2: rule__XTryCatchFinallyExpression__Group_3_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__Group_3_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__1"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__1__Impl"
+ // InternalOXtype.g:13898:1: rule__XTryCatchFinallyExpression__Group_3_0__1__Impl : ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? ) ;
+ public final void rule__XTryCatchFinallyExpression__Group_3_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13902:1: ( ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? ) )
+ // InternalOXtype.g:13903:1: ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? )
+ {
+ // InternalOXtype.g:13903:1: ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? )
+ // InternalOXtype.g:13904:2: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1());
+ }
+ // InternalOXtype.g:13905:2: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )?
+ int alt115=2;
+ int LA115_0 = input.LA(1);
+
+ if ( (LA115_0==78) ) {
+ int LA115_1 = input.LA(2);
+
+ if ( (synpred159_InternalOXtype()) ) {
+ alt115=1;
+ }
+ }
+ switch (alt115) {
+ case 1 :
+ // InternalOXtype.g:13905:3: rule__XTryCatchFinallyExpression__Group_3_0_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__Group_3_0_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__1__Impl"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__0"
+ // InternalOXtype.g:13914:1: rule__XTryCatchFinallyExpression__Group_3_0_1__0 : rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_0_1__1 ;
+ public final void rule__XTryCatchFinallyExpression__Group_3_0_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13918:1: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_0_1__1 )
+ // InternalOXtype.g:13919:2: rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_0_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__Group_3_0_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__0"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl"
+ // InternalOXtype.g:13926:1: rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl : ( ( 'finally' ) ) ;
+ public final void rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13930:1: ( ( ( 'finally' ) ) )
+ // InternalOXtype.g:13931:1: ( ( 'finally' ) )
+ {
+ // InternalOXtype.g:13931:1: ( ( 'finally' ) )
+ // InternalOXtype.g:13932:2: ( 'finally' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0());
+ }
+ // InternalOXtype.g:13933:2: ( 'finally' )
+ // InternalOXtype.g:13933:3: 'finally'
+ {
+ match(input,78,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__1"
+ // InternalOXtype.g:13941:1: rule__XTryCatchFinallyExpression__Group_3_0_1__1 : rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl ;
+ public final void rule__XTryCatchFinallyExpression__Group_3_0_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13945:1: ( rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl )
+ // InternalOXtype.g:13946:2: rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__1"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl"
+ // InternalOXtype.g:13952:1: rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl : ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) ) ;
+ public final void rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13956:1: ( ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) ) )
+ // InternalOXtype.g:13957:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) )
+ {
+ // InternalOXtype.g:13957:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) )
+ // InternalOXtype.g:13958:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1());
+ }
+ // InternalOXtype.g:13959:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 )
+ // InternalOXtype.g:13959:3: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__0"
+ // InternalOXtype.g:13968:1: rule__XTryCatchFinallyExpression__Group_3_1__0 : rule__XTryCatchFinallyExpression__Group_3_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_1__1 ;
+ public final void rule__XTryCatchFinallyExpression__Group_3_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13972:1: ( rule__XTryCatchFinallyExpression__Group_3_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_1__1 )
+ // InternalOXtype.g:13973:2: rule__XTryCatchFinallyExpression__Group_3_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_1__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XTryCatchFinallyExpression__Group_3_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__Group_3_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__0"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__0__Impl"
+ // InternalOXtype.g:13980:1: rule__XTryCatchFinallyExpression__Group_3_1__0__Impl : ( 'finally' ) ;
+ public final void rule__XTryCatchFinallyExpression__Group_3_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13984:1: ( ( 'finally' ) )
+ // InternalOXtype.g:13985:1: ( 'finally' )
+ {
+ // InternalOXtype.g:13985:1: ( 'finally' )
+ // InternalOXtype.g:13986:2: 'finally'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0());
+ }
+ match(input,78,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__0__Impl"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__1"
+ // InternalOXtype.g:13995:1: rule__XTryCatchFinallyExpression__Group_3_1__1 : rule__XTryCatchFinallyExpression__Group_3_1__1__Impl ;
+ public final void rule__XTryCatchFinallyExpression__Group_3_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:13999:1: ( rule__XTryCatchFinallyExpression__Group_3_1__1__Impl )
+ // InternalOXtype.g:14000:2: rule__XTryCatchFinallyExpression__Group_3_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__Group_3_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__1"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__1__Impl"
+ // InternalOXtype.g:14006:1: rule__XTryCatchFinallyExpression__Group_3_1__1__Impl : ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) ) ;
+ public final void rule__XTryCatchFinallyExpression__Group_3_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14010:1: ( ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) ) )
+ // InternalOXtype.g:14011:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) )
+ {
+ // InternalOXtype.g:14011:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) )
+ // InternalOXtype.g:14012:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1());
+ }
+ // InternalOXtype.g:14013:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 )
+ // InternalOXtype.g:14013:3: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__1__Impl"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__Group__0"
+ // InternalOXtype.g:14022:1: rule__XSynchronizedExpression__Group__0 : rule__XSynchronizedExpression__Group__0__Impl rule__XSynchronizedExpression__Group__1 ;
+ public final void rule__XSynchronizedExpression__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14026:1: ( rule__XSynchronizedExpression__Group__0__Impl rule__XSynchronizedExpression__Group__1 )
+ // InternalOXtype.g:14027:2: rule__XSynchronizedExpression__Group__0__Impl rule__XSynchronizedExpression__Group__1
+ {
+ pushFollow(FOLLOW_15);
+ rule__XSynchronizedExpression__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSynchronizedExpression__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__Group__0"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__Group__0__Impl"
+ // InternalOXtype.g:14034:1: rule__XSynchronizedExpression__Group__0__Impl : ( ( rule__XSynchronizedExpression__Group_0__0 ) ) ;
+ public final void rule__XSynchronizedExpression__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14038:1: ( ( ( rule__XSynchronizedExpression__Group_0__0 ) ) )
+ // InternalOXtype.g:14039:1: ( ( rule__XSynchronizedExpression__Group_0__0 ) )
+ {
+ // InternalOXtype.g:14039:1: ( ( rule__XSynchronizedExpression__Group_0__0 ) )
+ // InternalOXtype.g:14040:2: ( rule__XSynchronizedExpression__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0());
+ }
+ // InternalOXtype.g:14041:2: ( rule__XSynchronizedExpression__Group_0__0 )
+ // InternalOXtype.g:14041:3: rule__XSynchronizedExpression__Group_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSynchronizedExpression__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__Group__1"
+ // InternalOXtype.g:14049:1: rule__XSynchronizedExpression__Group__1 : rule__XSynchronizedExpression__Group__1__Impl rule__XSynchronizedExpression__Group__2 ;
+ public final void rule__XSynchronizedExpression__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14053:1: ( rule__XSynchronizedExpression__Group__1__Impl rule__XSynchronizedExpression__Group__2 )
+ // InternalOXtype.g:14054:2: rule__XSynchronizedExpression__Group__1__Impl rule__XSynchronizedExpression__Group__2
+ {
+ pushFollow(FOLLOW_61);
+ rule__XSynchronizedExpression__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSynchronizedExpression__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__Group__1"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__Group__1__Impl"
+ // InternalOXtype.g:14061:1: rule__XSynchronizedExpression__Group__1__Impl : ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) ) ;
+ public final void rule__XSynchronizedExpression__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14065:1: ( ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) ) )
+ // InternalOXtype.g:14066:1: ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) )
+ {
+ // InternalOXtype.g:14066:1: ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) )
+ // InternalOXtype.g:14067:2: ( rule__XSynchronizedExpression__ParamAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1());
+ }
+ // InternalOXtype.g:14068:2: ( rule__XSynchronizedExpression__ParamAssignment_1 )
+ // InternalOXtype.g:14068:3: rule__XSynchronizedExpression__ParamAssignment_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSynchronizedExpression__ParamAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__Group__2"
+ // InternalOXtype.g:14076:1: rule__XSynchronizedExpression__Group__2 : rule__XSynchronizedExpression__Group__2__Impl rule__XSynchronizedExpression__Group__3 ;
+ public final void rule__XSynchronizedExpression__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14080:1: ( rule__XSynchronizedExpression__Group__2__Impl rule__XSynchronizedExpression__Group__3 )
+ // InternalOXtype.g:14081:2: rule__XSynchronizedExpression__Group__2__Impl rule__XSynchronizedExpression__Group__3
+ {
+ pushFollow(FOLLOW_15);
+ rule__XSynchronizedExpression__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSynchronizedExpression__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__Group__2"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__Group__2__Impl"
+ // InternalOXtype.g:14088:1: rule__XSynchronizedExpression__Group__2__Impl : ( ')' ) ;
+ public final void rule__XSynchronizedExpression__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14092:1: ( ( ')' ) )
+ // InternalOXtype.g:14093:1: ( ')' )
+ {
+ // InternalOXtype.g:14093:1: ( ')' )
+ // InternalOXtype.g:14094:2: ')'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2());
+ }
+ match(input,54,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__Group__3"
+ // InternalOXtype.g:14103:1: rule__XSynchronizedExpression__Group__3 : rule__XSynchronizedExpression__Group__3__Impl ;
+ public final void rule__XSynchronizedExpression__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14107:1: ( rule__XSynchronizedExpression__Group__3__Impl )
+ // InternalOXtype.g:14108:2: rule__XSynchronizedExpression__Group__3__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSynchronizedExpression__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__Group__3"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__Group__3__Impl"
+ // InternalOXtype.g:14114:1: rule__XSynchronizedExpression__Group__3__Impl : ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) ) ;
+ public final void rule__XSynchronizedExpression__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14118:1: ( ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) ) )
+ // InternalOXtype.g:14119:1: ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) )
+ {
+ // InternalOXtype.g:14119:1: ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) )
+ // InternalOXtype.g:14120:2: ( rule__XSynchronizedExpression__ExpressionAssignment_3 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3());
+ }
+ // InternalOXtype.g:14121:2: ( rule__XSynchronizedExpression__ExpressionAssignment_3 )
+ // InternalOXtype.g:14121:3: rule__XSynchronizedExpression__ExpressionAssignment_3
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSynchronizedExpression__ExpressionAssignment_3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__Group_0__0"
+ // InternalOXtype.g:14130:1: rule__XSynchronizedExpression__Group_0__0 : rule__XSynchronizedExpression__Group_0__0__Impl ;
+ public final void rule__XSynchronizedExpression__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14134:1: ( rule__XSynchronizedExpression__Group_0__0__Impl )
+ // InternalOXtype.g:14135:2: rule__XSynchronizedExpression__Group_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSynchronizedExpression__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__Group_0__0"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__Group_0__0__Impl"
+ // InternalOXtype.g:14141:1: rule__XSynchronizedExpression__Group_0__0__Impl : ( ( rule__XSynchronizedExpression__Group_0_0__0 ) ) ;
+ public final void rule__XSynchronizedExpression__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14145:1: ( ( ( rule__XSynchronizedExpression__Group_0_0__0 ) ) )
+ // InternalOXtype.g:14146:1: ( ( rule__XSynchronizedExpression__Group_0_0__0 ) )
+ {
+ // InternalOXtype.g:14146:1: ( ( rule__XSynchronizedExpression__Group_0_0__0 ) )
+ // InternalOXtype.g:14147:2: ( rule__XSynchronizedExpression__Group_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0());
+ }
+ // InternalOXtype.g:14148:2: ( rule__XSynchronizedExpression__Group_0_0__0 )
+ // InternalOXtype.g:14148:3: rule__XSynchronizedExpression__Group_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSynchronizedExpression__Group_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__0"
+ // InternalOXtype.g:14157:1: rule__XSynchronizedExpression__Group_0_0__0 : rule__XSynchronizedExpression__Group_0_0__0__Impl rule__XSynchronizedExpression__Group_0_0__1 ;
+ public final void rule__XSynchronizedExpression__Group_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14161:1: ( rule__XSynchronizedExpression__Group_0_0__0__Impl rule__XSynchronizedExpression__Group_0_0__1 )
+ // InternalOXtype.g:14162:2: rule__XSynchronizedExpression__Group_0_0__0__Impl rule__XSynchronizedExpression__Group_0_0__1
+ {
+ pushFollow(FOLLOW_93);
+ rule__XSynchronizedExpression__Group_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSynchronizedExpression__Group_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__0"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__0__Impl"
+ // InternalOXtype.g:14169:1: rule__XSynchronizedExpression__Group_0_0__0__Impl : ( () ) ;
+ public final void rule__XSynchronizedExpression__Group_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14173:1: ( ( () ) )
+ // InternalOXtype.g:14174:1: ( () )
+ {
+ // InternalOXtype.g:14174:1: ( () )
+ // InternalOXtype.g:14175:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0());
+ }
+ // InternalOXtype.g:14176:2: ()
+ // InternalOXtype.g:14176:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__1"
+ // InternalOXtype.g:14184:1: rule__XSynchronizedExpression__Group_0_0__1 : rule__XSynchronizedExpression__Group_0_0__1__Impl rule__XSynchronizedExpression__Group_0_0__2 ;
+ public final void rule__XSynchronizedExpression__Group_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14188:1: ( rule__XSynchronizedExpression__Group_0_0__1__Impl rule__XSynchronizedExpression__Group_0_0__2 )
+ // InternalOXtype.g:14189:2: rule__XSynchronizedExpression__Group_0_0__1__Impl rule__XSynchronizedExpression__Group_0_0__2
+ {
+ pushFollow(FOLLOW_11);
+ rule__XSynchronizedExpression__Group_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XSynchronizedExpression__Group_0_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__1"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__1__Impl"
+ // InternalOXtype.g:14196:1: rule__XSynchronizedExpression__Group_0_0__1__Impl : ( 'synchronized' ) ;
+ public final void rule__XSynchronizedExpression__Group_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14200:1: ( ( 'synchronized' ) )
+ // InternalOXtype.g:14201:1: ( 'synchronized' )
+ {
+ // InternalOXtype.g:14201:1: ( 'synchronized' )
+ // InternalOXtype.g:14202:2: 'synchronized'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1());
+ }
+ match(input,79,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__2"
+ // InternalOXtype.g:14211:1: rule__XSynchronizedExpression__Group_0_0__2 : rule__XSynchronizedExpression__Group_0_0__2__Impl ;
+ public final void rule__XSynchronizedExpression__Group_0_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14215:1: ( rule__XSynchronizedExpression__Group_0_0__2__Impl )
+ // InternalOXtype.g:14216:2: rule__XSynchronizedExpression__Group_0_0__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSynchronizedExpression__Group_0_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__2"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__2__Impl"
+ // InternalOXtype.g:14222:1: rule__XSynchronizedExpression__Group_0_0__2__Impl : ( '(' ) ;
+ public final void rule__XSynchronizedExpression__Group_0_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14226:1: ( ( '(' ) )
+ // InternalOXtype.g:14227:1: ( '(' )
+ {
+ // InternalOXtype.g:14227:1: ( '(' )
+ // InternalOXtype.g:14228:2: '('
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2());
+ }
+ match(input,53,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__2__Impl"
+
+
+ // $ANTLR start "rule__XCatchClause__Group__0"
+ // InternalOXtype.g:14238:1: rule__XCatchClause__Group__0 : rule__XCatchClause__Group__0__Impl rule__XCatchClause__Group__1 ;
+ public final void rule__XCatchClause__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14242:1: ( rule__XCatchClause__Group__0__Impl rule__XCatchClause__Group__1 )
+ // InternalOXtype.g:14243:2: rule__XCatchClause__Group__0__Impl rule__XCatchClause__Group__1
+ {
+ pushFollow(FOLLOW_11);
+ rule__XCatchClause__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XCatchClause__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCatchClause__Group__0"
+
+
+ // $ANTLR start "rule__XCatchClause__Group__0__Impl"
+ // InternalOXtype.g:14250:1: rule__XCatchClause__Group__0__Impl : ( ( 'catch' ) ) ;
+ public final void rule__XCatchClause__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14254:1: ( ( ( 'catch' ) ) )
+ // InternalOXtype.g:14255:1: ( ( 'catch' ) )
+ {
+ // InternalOXtype.g:14255:1: ( ( 'catch' ) )
+ // InternalOXtype.g:14256:2: ( 'catch' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0());
+ }
+ // InternalOXtype.g:14257:2: ( 'catch' )
+ // InternalOXtype.g:14257:3: 'catch'
+ {
+ match(input,80,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCatchClause__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XCatchClause__Group__1"
+ // InternalOXtype.g:14265:1: rule__XCatchClause__Group__1 : rule__XCatchClause__Group__1__Impl rule__XCatchClause__Group__2 ;
+ public final void rule__XCatchClause__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14269:1: ( rule__XCatchClause__Group__1__Impl rule__XCatchClause__Group__2 )
+ // InternalOXtype.g:14270:2: rule__XCatchClause__Group__1__Impl rule__XCatchClause__Group__2
+ {
+ pushFollow(FOLLOW_32);
+ rule__XCatchClause__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XCatchClause__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCatchClause__Group__1"
+
+
+ // $ANTLR start "rule__XCatchClause__Group__1__Impl"
+ // InternalOXtype.g:14277:1: rule__XCatchClause__Group__1__Impl : ( '(' ) ;
+ public final void rule__XCatchClause__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14281:1: ( ( '(' ) )
+ // InternalOXtype.g:14282:1: ( '(' )
+ {
+ // InternalOXtype.g:14282:1: ( '(' )
+ // InternalOXtype.g:14283:2: '('
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1());
+ }
+ match(input,53,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCatchClause__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XCatchClause__Group__2"
+ // InternalOXtype.g:14292:1: rule__XCatchClause__Group__2 : rule__XCatchClause__Group__2__Impl rule__XCatchClause__Group__3 ;
+ public final void rule__XCatchClause__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14296:1: ( rule__XCatchClause__Group__2__Impl rule__XCatchClause__Group__3 )
+ // InternalOXtype.g:14297:2: rule__XCatchClause__Group__2__Impl rule__XCatchClause__Group__3
+ {
+ pushFollow(FOLLOW_61);
+ rule__XCatchClause__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XCatchClause__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCatchClause__Group__2"
+
+
+ // $ANTLR start "rule__XCatchClause__Group__2__Impl"
+ // InternalOXtype.g:14304:1: rule__XCatchClause__Group__2__Impl : ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) ) ;
+ public final void rule__XCatchClause__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14308:1: ( ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) ) )
+ // InternalOXtype.g:14309:1: ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) )
+ {
+ // InternalOXtype.g:14309:1: ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) )
+ // InternalOXtype.g:14310:2: ( rule__XCatchClause__DeclaredParamAssignment_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2());
+ }
+ // InternalOXtype.g:14311:2: ( rule__XCatchClause__DeclaredParamAssignment_2 )
+ // InternalOXtype.g:14311:3: rule__XCatchClause__DeclaredParamAssignment_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCatchClause__DeclaredParamAssignment_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCatchClause__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XCatchClause__Group__3"
+ // InternalOXtype.g:14319:1: rule__XCatchClause__Group__3 : rule__XCatchClause__Group__3__Impl rule__XCatchClause__Group__4 ;
+ public final void rule__XCatchClause__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14323:1: ( rule__XCatchClause__Group__3__Impl rule__XCatchClause__Group__4 )
+ // InternalOXtype.g:14324:2: rule__XCatchClause__Group__3__Impl rule__XCatchClause__Group__4
+ {
+ pushFollow(FOLLOW_15);
+ rule__XCatchClause__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XCatchClause__Group__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCatchClause__Group__3"
+
+
+ // $ANTLR start "rule__XCatchClause__Group__3__Impl"
+ // InternalOXtype.g:14331:1: rule__XCatchClause__Group__3__Impl : ( ')' ) ;
+ public final void rule__XCatchClause__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14335:1: ( ( ')' ) )
+ // InternalOXtype.g:14336:1: ( ')' )
+ {
+ // InternalOXtype.g:14336:1: ( ')' )
+ // InternalOXtype.g:14337:2: ')'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3());
+ }
+ match(input,54,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCatchClause__Group__3__Impl"
+
+
+ // $ANTLR start "rule__XCatchClause__Group__4"
+ // InternalOXtype.g:14346:1: rule__XCatchClause__Group__4 : rule__XCatchClause__Group__4__Impl ;
+ public final void rule__XCatchClause__Group__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14350:1: ( rule__XCatchClause__Group__4__Impl )
+ // InternalOXtype.g:14351:2: rule__XCatchClause__Group__4__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCatchClause__Group__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCatchClause__Group__4"
+
+
+ // $ANTLR start "rule__XCatchClause__Group__4__Impl"
+ // InternalOXtype.g:14357:1: rule__XCatchClause__Group__4__Impl : ( ( rule__XCatchClause__ExpressionAssignment_4 ) ) ;
+ public final void rule__XCatchClause__Group__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14361:1: ( ( ( rule__XCatchClause__ExpressionAssignment_4 ) ) )
+ // InternalOXtype.g:14362:1: ( ( rule__XCatchClause__ExpressionAssignment_4 ) )
+ {
+ // InternalOXtype.g:14362:1: ( ( rule__XCatchClause__ExpressionAssignment_4 ) )
+ // InternalOXtype.g:14363:2: ( rule__XCatchClause__ExpressionAssignment_4 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4());
+ }
+ // InternalOXtype.g:14364:2: ( rule__XCatchClause__ExpressionAssignment_4 )
+ // InternalOXtype.g:14364:3: rule__XCatchClause__ExpressionAssignment_4
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCatchClause__ExpressionAssignment_4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCatchClause__Group__4__Impl"
+
+
+ // $ANTLR start "rule__QualifiedName__Group__0"
+ // InternalOXtype.g:14373:1: rule__QualifiedName__Group__0 : rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 ;
+ public final void rule__QualifiedName__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14377:1: ( rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 )
+ // InternalOXtype.g:14378:2: rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1
+ {
+ pushFollow(FOLLOW_94);
+ rule__QualifiedName__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__QualifiedName__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedName__Group__0"
+
+
+ // $ANTLR start "rule__QualifiedName__Group__0__Impl"
+ // InternalOXtype.g:14385:1: rule__QualifiedName__Group__0__Impl : ( ruleValidID ) ;
+ public final void rule__QualifiedName__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14389:1: ( ( ruleValidID ) )
+ // InternalOXtype.g:14390:1: ( ruleValidID )
+ {
+ // InternalOXtype.g:14390:1: ( ruleValidID )
+ // InternalOXtype.g:14391:2: ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedName__Group__0__Impl"
+
+
+ // $ANTLR start "rule__QualifiedName__Group__1"
+ // InternalOXtype.g:14400:1: rule__QualifiedName__Group__1 : rule__QualifiedName__Group__1__Impl ;
+ public final void rule__QualifiedName__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14404:1: ( rule__QualifiedName__Group__1__Impl )
+ // InternalOXtype.g:14405:2: rule__QualifiedName__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__QualifiedName__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedName__Group__1"
+
+
+ // $ANTLR start "rule__QualifiedName__Group__1__Impl"
+ // InternalOXtype.g:14411:1: rule__QualifiedName__Group__1__Impl : ( ( rule__QualifiedName__Group_1__0 )* ) ;
+ public final void rule__QualifiedName__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14415:1: ( ( ( rule__QualifiedName__Group_1__0 )* ) )
+ // InternalOXtype.g:14416:1: ( ( rule__QualifiedName__Group_1__0 )* )
+ {
+ // InternalOXtype.g:14416:1: ( ( rule__QualifiedName__Group_1__0 )* )
+ // InternalOXtype.g:14417:2: ( rule__QualifiedName__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getQualifiedNameAccess().getGroup_1());
+ }
+ // InternalOXtype.g:14418:2: ( rule__QualifiedName__Group_1__0 )*
+ loop116:
+ do {
+ int alt116=2;
+ int LA116_0 = input.LA(1);
+
+ if ( (LA116_0==43) ) {
+ int LA116_2 = input.LA(2);
+
+ if ( (LA116_2==RULE_ID) ) {
+ int LA116_3 = input.LA(3);
+
+ if ( (synpred160_InternalOXtype()) ) {
+ alt116=1;
+ }
+
+
+ }
+
+
+ }
+
+
+ switch (alt116) {
+ case 1 :
+ // InternalOXtype.g:14418:3: rule__QualifiedName__Group_1__0
+ {
+ pushFollow(FOLLOW_95);
+ rule__QualifiedName__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop116;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getQualifiedNameAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedName__Group__1__Impl"
+
+
+ // $ANTLR start "rule__QualifiedName__Group_1__0"
+ // InternalOXtype.g:14427:1: rule__QualifiedName__Group_1__0 : rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ;
+ public final void rule__QualifiedName__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14431:1: ( rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 )
+ // InternalOXtype.g:14432:2: rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1
+ {
+ pushFollow(FOLLOW_9);
+ rule__QualifiedName__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__QualifiedName__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedName__Group_1__0"
+
+
+ // $ANTLR start "rule__QualifiedName__Group_1__0__Impl"
+ // InternalOXtype.g:14439:1: rule__QualifiedName__Group_1__0__Impl : ( ( '.' ) ) ;
+ public final void rule__QualifiedName__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14443:1: ( ( ( '.' ) ) )
+ // InternalOXtype.g:14444:1: ( ( '.' ) )
+ {
+ // InternalOXtype.g:14444:1: ( ( '.' ) )
+ // InternalOXtype.g:14445:2: ( '.' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0());
+ }
+ // InternalOXtype.g:14446:2: ( '.' )
+ // InternalOXtype.g:14446:3: '.'
+ {
+ match(input,43,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedName__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__QualifiedName__Group_1__1"
+ // InternalOXtype.g:14454:1: rule__QualifiedName__Group_1__1 : rule__QualifiedName__Group_1__1__Impl ;
+ public final void rule__QualifiedName__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14458:1: ( rule__QualifiedName__Group_1__1__Impl )
+ // InternalOXtype.g:14459:2: rule__QualifiedName__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__QualifiedName__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedName__Group_1__1"
+
+
+ // $ANTLR start "rule__QualifiedName__Group_1__1__Impl"
+ // InternalOXtype.g:14465:1: rule__QualifiedName__Group_1__1__Impl : ( ruleValidID ) ;
+ public final void rule__QualifiedName__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14469:1: ( ( ruleValidID ) )
+ // InternalOXtype.g:14470:1: ( ruleValidID )
+ {
+ // InternalOXtype.g:14470:1: ( ruleValidID )
+ // InternalOXtype.g:14471:2: ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedName__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__Number__Group_1__0"
+ // InternalOXtype.g:14481:1: rule__Number__Group_1__0 : rule__Number__Group_1__0__Impl rule__Number__Group_1__1 ;
+ public final void rule__Number__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14485:1: ( rule__Number__Group_1__0__Impl rule__Number__Group_1__1 )
+ // InternalOXtype.g:14486:2: rule__Number__Group_1__0__Impl rule__Number__Group_1__1
+ {
+ pushFollow(FOLLOW_94);
+ rule__Number__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__Number__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Number__Group_1__0"
+
+
+ // $ANTLR start "rule__Number__Group_1__0__Impl"
+ // InternalOXtype.g:14493:1: rule__Number__Group_1__0__Impl : ( ( rule__Number__Alternatives_1_0 ) ) ;
+ public final void rule__Number__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14497:1: ( ( ( rule__Number__Alternatives_1_0 ) ) )
+ // InternalOXtype.g:14498:1: ( ( rule__Number__Alternatives_1_0 ) )
+ {
+ // InternalOXtype.g:14498:1: ( ( rule__Number__Alternatives_1_0 ) )
+ // InternalOXtype.g:14499:2: ( rule__Number__Alternatives_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNumberAccess().getAlternatives_1_0());
+ }
+ // InternalOXtype.g:14500:2: ( rule__Number__Alternatives_1_0 )
+ // InternalOXtype.g:14500:3: rule__Number__Alternatives_1_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__Number__Alternatives_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNumberAccess().getAlternatives_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Number__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__Number__Group_1__1"
+ // InternalOXtype.g:14508:1: rule__Number__Group_1__1 : rule__Number__Group_1__1__Impl ;
+ public final void rule__Number__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14512:1: ( rule__Number__Group_1__1__Impl )
+ // InternalOXtype.g:14513:2: rule__Number__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__Number__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Number__Group_1__1"
+
+
+ // $ANTLR start "rule__Number__Group_1__1__Impl"
+ // InternalOXtype.g:14519:1: rule__Number__Group_1__1__Impl : ( ( rule__Number__Group_1_1__0 )? ) ;
+ public final void rule__Number__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14523:1: ( ( ( rule__Number__Group_1_1__0 )? ) )
+ // InternalOXtype.g:14524:1: ( ( rule__Number__Group_1_1__0 )? )
+ {
+ // InternalOXtype.g:14524:1: ( ( rule__Number__Group_1_1__0 )? )
+ // InternalOXtype.g:14525:2: ( rule__Number__Group_1_1__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNumberAccess().getGroup_1_1());
+ }
+ // InternalOXtype.g:14526:2: ( rule__Number__Group_1_1__0 )?
+ int alt117=2;
+ int LA117_0 = input.LA(1);
+
+ if ( (LA117_0==43) ) {
+ int LA117_1 = input.LA(2);
+
+ if ( ((LA117_1>=RULE_INT && LA117_1<=RULE_DECIMAL)) ) {
+ alt117=1;
+ }
+ }
+ switch (alt117) {
+ case 1 :
+ // InternalOXtype.g:14526:3: rule__Number__Group_1_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__Number__Group_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNumberAccess().getGroup_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Number__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__Number__Group_1_1__0"
+ // InternalOXtype.g:14535:1: rule__Number__Group_1_1__0 : rule__Number__Group_1_1__0__Impl rule__Number__Group_1_1__1 ;
+ public final void rule__Number__Group_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14539:1: ( rule__Number__Group_1_1__0__Impl rule__Number__Group_1_1__1 )
+ // InternalOXtype.g:14540:2: rule__Number__Group_1_1__0__Impl rule__Number__Group_1_1__1
+ {
+ pushFollow(FOLLOW_96);
+ rule__Number__Group_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__Number__Group_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Number__Group_1_1__0"
+
+
+ // $ANTLR start "rule__Number__Group_1_1__0__Impl"
+ // InternalOXtype.g:14547:1: rule__Number__Group_1_1__0__Impl : ( '.' ) ;
+ public final void rule__Number__Group_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14551:1: ( ( '.' ) )
+ // InternalOXtype.g:14552:1: ( '.' )
+ {
+ // InternalOXtype.g:14552:1: ( '.' )
+ // InternalOXtype.g:14553:2: '.'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0());
+ }
+ match(input,43,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Number__Group_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__Number__Group_1_1__1"
+ // InternalOXtype.g:14562:1: rule__Number__Group_1_1__1 : rule__Number__Group_1_1__1__Impl ;
+ public final void rule__Number__Group_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14566:1: ( rule__Number__Group_1_1__1__Impl )
+ // InternalOXtype.g:14567:2: rule__Number__Group_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__Number__Group_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Number__Group_1_1__1"
+
+
+ // $ANTLR start "rule__Number__Group_1_1__1__Impl"
+ // InternalOXtype.g:14573:1: rule__Number__Group_1_1__1__Impl : ( ( rule__Number__Alternatives_1_1_1 ) ) ;
+ public final void rule__Number__Group_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14577:1: ( ( ( rule__Number__Alternatives_1_1_1 ) ) )
+ // InternalOXtype.g:14578:1: ( ( rule__Number__Alternatives_1_1_1 ) )
+ {
+ // InternalOXtype.g:14578:1: ( ( rule__Number__Alternatives_1_1_1 ) )
+ // InternalOXtype.g:14579:2: ( rule__Number__Alternatives_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNumberAccess().getAlternatives_1_1_1());
+ }
+ // InternalOXtype.g:14580:2: ( rule__Number__Alternatives_1_1_1 )
+ // InternalOXtype.g:14580:3: rule__Number__Alternatives_1_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__Number__Alternatives_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNumberAccess().getAlternatives_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Number__Group_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__JvmTypeReference__Group_0__0"
+ // InternalOXtype.g:14589:1: rule__JvmTypeReference__Group_0__0 : rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1 ;
+ public final void rule__JvmTypeReference__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14593:1: ( rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1 )
+ // InternalOXtype.g:14594:2: rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1
+ {
+ pushFollow(FOLLOW_19);
+ rule__JvmTypeReference__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmTypeReference__Group_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmTypeReference__Group_0__0"
+
+
+ // $ANTLR start "rule__JvmTypeReference__Group_0__0__Impl"
+ // InternalOXtype.g:14601:1: rule__JvmTypeReference__Group_0__0__Impl : ( ruleJvmParameterizedTypeReference ) ;
+ public final void rule__JvmTypeReference__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14605:1: ( ( ruleJvmParameterizedTypeReference ) )
+ // InternalOXtype.g:14606:1: ( ruleJvmParameterizedTypeReference )
+ {
+ // InternalOXtype.g:14606:1: ( ruleJvmParameterizedTypeReference )
+ // InternalOXtype.g:14607:2: ruleJvmParameterizedTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmParameterizedTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmTypeReference__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__JvmTypeReference__Group_0__1"
+ // InternalOXtype.g:14616:1: rule__JvmTypeReference__Group_0__1 : rule__JvmTypeReference__Group_0__1__Impl ;
+ public final void rule__JvmTypeReference__Group_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14620:1: ( rule__JvmTypeReference__Group_0__1__Impl )
+ // InternalOXtype.g:14621:2: rule__JvmTypeReference__Group_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmTypeReference__Group_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmTypeReference__Group_0__1"
+
+
+ // $ANTLR start "rule__JvmTypeReference__Group_0__1__Impl"
+ // InternalOXtype.g:14627:1: rule__JvmTypeReference__Group_0__1__Impl : ( ( rule__JvmTypeReference__Group_0_1__0 )* ) ;
+ public final void rule__JvmTypeReference__Group_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14631:1: ( ( ( rule__JvmTypeReference__Group_0_1__0 )* ) )
+ // InternalOXtype.g:14632:1: ( ( rule__JvmTypeReference__Group_0_1__0 )* )
+ {
+ // InternalOXtype.g:14632:1: ( ( rule__JvmTypeReference__Group_0_1__0 )* )
+ // InternalOXtype.g:14633:2: ( rule__JvmTypeReference__Group_0_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1());
+ }
+ // InternalOXtype.g:14634:2: ( rule__JvmTypeReference__Group_0_1__0 )*
+ loop118:
+ do {
+ int alt118=2;
+ int LA118_0 = input.LA(1);
+
+ if ( (LA118_0==58) ) {
+ int LA118_2 = input.LA(2);
+
+ if ( (LA118_2==56) ) {
+ int LA118_3 = input.LA(3);
+
+ if ( (synpred162_InternalOXtype()) ) {
+ alt118=1;
+ }
+
+
+ }
+
+
+ }
+
+
+ switch (alt118) {
+ case 1 :
+ // InternalOXtype.g:14634:3: rule__JvmTypeReference__Group_0_1__0
+ {
+ pushFollow(FOLLOW_86);
+ rule__JvmTypeReference__Group_0_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop118;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmTypeReference__Group_0__1__Impl"
+
+
+ // $ANTLR start "rule__JvmTypeReference__Group_0_1__0"
+ // InternalOXtype.g:14643:1: rule__JvmTypeReference__Group_0_1__0 : rule__JvmTypeReference__Group_0_1__0__Impl ;
+ public final void rule__JvmTypeReference__Group_0_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14647:1: ( rule__JvmTypeReference__Group_0_1__0__Impl )
+ // InternalOXtype.g:14648:2: rule__JvmTypeReference__Group_0_1__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmTypeReference__Group_0_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmTypeReference__Group_0_1__0"
+
+
+ // $ANTLR start "rule__JvmTypeReference__Group_0_1__0__Impl"
+ // InternalOXtype.g:14654:1: rule__JvmTypeReference__Group_0_1__0__Impl : ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) ;
+ public final void rule__JvmTypeReference__Group_0_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14658:1: ( ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) )
+ // InternalOXtype.g:14659:1: ( ( rule__JvmTypeReference__Group_0_1_0__0 ) )
+ {
+ // InternalOXtype.g:14659:1: ( ( rule__JvmTypeReference__Group_0_1_0__0 ) )
+ // InternalOXtype.g:14660:2: ( rule__JvmTypeReference__Group_0_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0());
+ }
+ // InternalOXtype.g:14661:2: ( rule__JvmTypeReference__Group_0_1_0__0 )
+ // InternalOXtype.g:14661:3: rule__JvmTypeReference__Group_0_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmTypeReference__Group_0_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmTypeReference__Group_0_1__0__Impl"
+
+
+ // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__0"
+ // InternalOXtype.g:14670:1: rule__JvmTypeReference__Group_0_1_0__0 : rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1 ;
+ public final void rule__JvmTypeReference__Group_0_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14674:1: ( rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1 )
+ // InternalOXtype.g:14675:2: rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1
+ {
+ pushFollow(FOLLOW_19);
+ rule__JvmTypeReference__Group_0_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmTypeReference__Group_0_1_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__0"
+
+
+ // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__0__Impl"
+ // InternalOXtype.g:14682:1: rule__JvmTypeReference__Group_0_1_0__0__Impl : ( () ) ;
+ public final void rule__JvmTypeReference__Group_0_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14686:1: ( ( () ) )
+ // InternalOXtype.g:14687:1: ( () )
+ {
+ // InternalOXtype.g:14687:1: ( () )
+ // InternalOXtype.g:14688:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0());
+ }
+ // InternalOXtype.g:14689:2: ()
+ // InternalOXtype.g:14689:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__1"
+ // InternalOXtype.g:14697:1: rule__JvmTypeReference__Group_0_1_0__1 : rule__JvmTypeReference__Group_0_1_0__1__Impl ;
+ public final void rule__JvmTypeReference__Group_0_1_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14701:1: ( rule__JvmTypeReference__Group_0_1_0__1__Impl )
+ // InternalOXtype.g:14702:2: rule__JvmTypeReference__Group_0_1_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmTypeReference__Group_0_1_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__1"
+
+
+ // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__1__Impl"
+ // InternalOXtype.g:14708:1: rule__JvmTypeReference__Group_0_1_0__1__Impl : ( ruleArrayBrackets ) ;
+ public final void rule__JvmTypeReference__Group_0_1_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14712:1: ( ( ruleArrayBrackets ) )
+ // InternalOXtype.g:14713:1: ( ruleArrayBrackets )
+ {
+ // InternalOXtype.g:14713:1: ( ruleArrayBrackets )
+ // InternalOXtype.g:14714:2: ruleArrayBrackets
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleArrayBrackets();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__1__Impl"
+
+
+ // $ANTLR start "rule__ArrayBrackets__Group__0"
+ // InternalOXtype.g:14724:1: rule__ArrayBrackets__Group__0 : rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1 ;
+ public final void rule__ArrayBrackets__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14728:1: ( rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1 )
+ // InternalOXtype.g:14729:2: rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1
+ {
+ pushFollow(FOLLOW_58);
+ rule__ArrayBrackets__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__ArrayBrackets__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArrayBrackets__Group__0"
+
+
+ // $ANTLR start "rule__ArrayBrackets__Group__0__Impl"
+ // InternalOXtype.g:14736:1: rule__ArrayBrackets__Group__0__Impl : ( '[' ) ;
+ public final void rule__ArrayBrackets__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14740:1: ( ( '[' ) )
+ // InternalOXtype.g:14741:1: ( '[' )
+ {
+ // InternalOXtype.g:14741:1: ( '[' )
+ // InternalOXtype.g:14742:2: '['
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0());
+ }
+ match(input,58,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArrayBrackets__Group__0__Impl"
+
+
+ // $ANTLR start "rule__ArrayBrackets__Group__1"
+ // InternalOXtype.g:14751:1: rule__ArrayBrackets__Group__1 : rule__ArrayBrackets__Group__1__Impl ;
+ public final void rule__ArrayBrackets__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14755:1: ( rule__ArrayBrackets__Group__1__Impl )
+ // InternalOXtype.g:14756:2: rule__ArrayBrackets__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__ArrayBrackets__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArrayBrackets__Group__1"
+
+
+ // $ANTLR start "rule__ArrayBrackets__Group__1__Impl"
+ // InternalOXtype.g:14762:1: rule__ArrayBrackets__Group__1__Impl : ( ']' ) ;
+ public final void rule__ArrayBrackets__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14766:1: ( ( ']' ) )
+ // InternalOXtype.g:14767:1: ( ']' )
+ {
+ // InternalOXtype.g:14767:1: ( ']' )
+ // InternalOXtype.g:14768:2: ']'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1());
+ }
+ match(input,56,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArrayBrackets__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group__0"
+ // InternalOXtype.g:14778:1: rule__XFunctionTypeRef__Group__0 : rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1 ;
+ public final void rule__XFunctionTypeRef__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14782:1: ( rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1 )
+ // InternalOXtype.g:14783:2: rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1
+ {
+ pushFollow(FOLLOW_32);
+ rule__XFunctionTypeRef__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFunctionTypeRef__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group__0"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group__0__Impl"
+ // InternalOXtype.g:14790:1: rule__XFunctionTypeRef__Group__0__Impl : ( ( rule__XFunctionTypeRef__Group_0__0 )? ) ;
+ public final void rule__XFunctionTypeRef__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14794:1: ( ( ( rule__XFunctionTypeRef__Group_0__0 )? ) )
+ // InternalOXtype.g:14795:1: ( ( rule__XFunctionTypeRef__Group_0__0 )? )
+ {
+ // InternalOXtype.g:14795:1: ( ( rule__XFunctionTypeRef__Group_0__0 )? )
+ // InternalOXtype.g:14796:2: ( rule__XFunctionTypeRef__Group_0__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0());
+ }
+ // InternalOXtype.g:14797:2: ( rule__XFunctionTypeRef__Group_0__0 )?
+ int alt119=2;
+ int LA119_0 = input.LA(1);
+
+ if ( (LA119_0==53) ) {
+ alt119=1;
+ }
+ switch (alt119) {
+ case 1 :
+ // InternalOXtype.g:14797:3: rule__XFunctionTypeRef__Group_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFunctionTypeRef__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group__0__Impl"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group__1"
+ // InternalOXtype.g:14805:1: rule__XFunctionTypeRef__Group__1 : rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2 ;
+ public final void rule__XFunctionTypeRef__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14809:1: ( rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2 )
+ // InternalOXtype.g:14810:2: rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2
+ {
+ pushFollow(FOLLOW_32);
+ rule__XFunctionTypeRef__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFunctionTypeRef__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group__1"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group__1__Impl"
+ // InternalOXtype.g:14817:1: rule__XFunctionTypeRef__Group__1__Impl : ( '=>' ) ;
+ public final void rule__XFunctionTypeRef__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14821:1: ( ( '=>' ) )
+ // InternalOXtype.g:14822:1: ( '=>' )
+ {
+ // InternalOXtype.g:14822:1: ( '=>' )
+ // InternalOXtype.g:14823:2: '=>'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1());
+ }
+ match(input,31,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group__2"
+ // InternalOXtype.g:14832:1: rule__XFunctionTypeRef__Group__2 : rule__XFunctionTypeRef__Group__2__Impl ;
+ public final void rule__XFunctionTypeRef__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14836:1: ( rule__XFunctionTypeRef__Group__2__Impl )
+ // InternalOXtype.g:14837:2: rule__XFunctionTypeRef__Group__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFunctionTypeRef__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group__2"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group__2__Impl"
+ // InternalOXtype.g:14843:1: rule__XFunctionTypeRef__Group__2__Impl : ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) ;
+ public final void rule__XFunctionTypeRef__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14847:1: ( ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) )
+ // InternalOXtype.g:14848:1: ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) )
+ {
+ // InternalOXtype.g:14848:1: ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) )
+ // InternalOXtype.g:14849:2: ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2());
+ }
+ // InternalOXtype.g:14850:2: ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 )
+ // InternalOXtype.g:14850:3: rule__XFunctionTypeRef__ReturnTypeAssignment_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFunctionTypeRef__ReturnTypeAssignment_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group__2__Impl"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group_0__0"
+ // InternalOXtype.g:14859:1: rule__XFunctionTypeRef__Group_0__0 : rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1 ;
+ public final void rule__XFunctionTypeRef__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14863:1: ( rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1 )
+ // InternalOXtype.g:14864:2: rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1
+ {
+ pushFollow(FOLLOW_97);
+ rule__XFunctionTypeRef__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFunctionTypeRef__Group_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group_0__0"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group_0__0__Impl"
+ // InternalOXtype.g:14871:1: rule__XFunctionTypeRef__Group_0__0__Impl : ( '(' ) ;
+ public final void rule__XFunctionTypeRef__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14875:1: ( ( '(' ) )
+ // InternalOXtype.g:14876:1: ( '(' )
+ {
+ // InternalOXtype.g:14876:1: ( '(' )
+ // InternalOXtype.g:14877:2: '('
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0());
+ }
+ match(input,53,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group_0__1"
+ // InternalOXtype.g:14886:1: rule__XFunctionTypeRef__Group_0__1 : rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2 ;
+ public final void rule__XFunctionTypeRef__Group_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14890:1: ( rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2 )
+ // InternalOXtype.g:14891:2: rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2
+ {
+ pushFollow(FOLLOW_97);
+ rule__XFunctionTypeRef__Group_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFunctionTypeRef__Group_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group_0__1"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group_0__1__Impl"
+ // InternalOXtype.g:14898:1: rule__XFunctionTypeRef__Group_0__1__Impl : ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) ;
+ public final void rule__XFunctionTypeRef__Group_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14902:1: ( ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) )
+ // InternalOXtype.g:14903:1: ( ( rule__XFunctionTypeRef__Group_0_1__0 )? )
+ {
+ // InternalOXtype.g:14903:1: ( ( rule__XFunctionTypeRef__Group_0_1__0 )? )
+ // InternalOXtype.g:14904:2: ( rule__XFunctionTypeRef__Group_0_1__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1());
+ }
+ // InternalOXtype.g:14905:2: ( rule__XFunctionTypeRef__Group_0_1__0 )?
+ int alt120=2;
+ int LA120_0 = input.LA(1);
+
+ if ( (LA120_0==RULE_ID||LA120_0==31||LA120_0==53) ) {
+ alt120=1;
+ }
+ switch (alt120) {
+ case 1 :
+ // InternalOXtype.g:14905:3: rule__XFunctionTypeRef__Group_0_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFunctionTypeRef__Group_0_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group_0__1__Impl"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group_0__2"
+ // InternalOXtype.g:14913:1: rule__XFunctionTypeRef__Group_0__2 : rule__XFunctionTypeRef__Group_0__2__Impl ;
+ public final void rule__XFunctionTypeRef__Group_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14917:1: ( rule__XFunctionTypeRef__Group_0__2__Impl )
+ // InternalOXtype.g:14918:2: rule__XFunctionTypeRef__Group_0__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFunctionTypeRef__Group_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group_0__2"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group_0__2__Impl"
+ // InternalOXtype.g:14924:1: rule__XFunctionTypeRef__Group_0__2__Impl : ( ')' ) ;
+ public final void rule__XFunctionTypeRef__Group_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14928:1: ( ( ')' ) )
+ // InternalOXtype.g:14929:1: ( ')' )
+ {
+ // InternalOXtype.g:14929:1: ( ')' )
+ // InternalOXtype.g:14930:2: ')'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2());
+ }
+ match(input,54,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group_0__2__Impl"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__0"
+ // InternalOXtype.g:14940:1: rule__XFunctionTypeRef__Group_0_1__0 : rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1 ;
+ public final void rule__XFunctionTypeRef__Group_0_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14944:1: ( rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1 )
+ // InternalOXtype.g:14945:2: rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1
+ {
+ pushFollow(FOLLOW_13);
+ rule__XFunctionTypeRef__Group_0_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFunctionTypeRef__Group_0_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__0"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__0__Impl"
+ // InternalOXtype.g:14952:1: rule__XFunctionTypeRef__Group_0_1__0__Impl : ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) ;
+ public final void rule__XFunctionTypeRef__Group_0_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14956:1: ( ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) )
+ // InternalOXtype.g:14957:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) )
+ {
+ // InternalOXtype.g:14957:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) )
+ // InternalOXtype.g:14958:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0());
+ }
+ // InternalOXtype.g:14959:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 )
+ // InternalOXtype.g:14959:3: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__0__Impl"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__1"
+ // InternalOXtype.g:14967:1: rule__XFunctionTypeRef__Group_0_1__1 : rule__XFunctionTypeRef__Group_0_1__1__Impl ;
+ public final void rule__XFunctionTypeRef__Group_0_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14971:1: ( rule__XFunctionTypeRef__Group_0_1__1__Impl )
+ // InternalOXtype.g:14972:2: rule__XFunctionTypeRef__Group_0_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFunctionTypeRef__Group_0_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__1"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__1__Impl"
+ // InternalOXtype.g:14978:1: rule__XFunctionTypeRef__Group_0_1__1__Impl : ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) ;
+ public final void rule__XFunctionTypeRef__Group_0_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14982:1: ( ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) )
+ // InternalOXtype.g:14983:1: ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* )
+ {
+ // InternalOXtype.g:14983:1: ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* )
+ // InternalOXtype.g:14984:2: ( rule__XFunctionTypeRef__Group_0_1_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1());
+ }
+ // InternalOXtype.g:14985:2: ( rule__XFunctionTypeRef__Group_0_1_1__0 )*
+ loop121:
+ do {
+ int alt121=2;
+ int LA121_0 = input.LA(1);
+
+ if ( (LA121_0==55) ) {
+ alt121=1;
+ }
+
+
+ switch (alt121) {
+ case 1 :
+ // InternalOXtype.g:14985:3: rule__XFunctionTypeRef__Group_0_1_1__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__XFunctionTypeRef__Group_0_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop121;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__1__Impl"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__0"
+ // InternalOXtype.g:14994:1: rule__XFunctionTypeRef__Group_0_1_1__0 : rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1 ;
+ public final void rule__XFunctionTypeRef__Group_0_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:14998:1: ( rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1 )
+ // InternalOXtype.g:14999:2: rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1
+ {
+ pushFollow(FOLLOW_32);
+ rule__XFunctionTypeRef__Group_0_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__XFunctionTypeRef__Group_0_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__0"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__0__Impl"
+ // InternalOXtype.g:15006:1: rule__XFunctionTypeRef__Group_0_1_1__0__Impl : ( ',' ) ;
+ public final void rule__XFunctionTypeRef__Group_0_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15010:1: ( ( ',' ) )
+ // InternalOXtype.g:15011:1: ( ',' )
+ {
+ // InternalOXtype.g:15011:1: ( ',' )
+ // InternalOXtype.g:15012:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__1"
+ // InternalOXtype.g:15021:1: rule__XFunctionTypeRef__Group_0_1_1__1 : rule__XFunctionTypeRef__Group_0_1_1__1__Impl ;
+ public final void rule__XFunctionTypeRef__Group_0_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15025:1: ( rule__XFunctionTypeRef__Group_0_1_1__1__Impl )
+ // InternalOXtype.g:15026:2: rule__XFunctionTypeRef__Group_0_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFunctionTypeRef__Group_0_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__1"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__1__Impl"
+ // InternalOXtype.g:15032:1: rule__XFunctionTypeRef__Group_0_1_1__1__Impl : ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) ;
+ public final void rule__XFunctionTypeRef__Group_0_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15036:1: ( ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) )
+ // InternalOXtype.g:15037:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) )
+ {
+ // InternalOXtype.g:15037:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) )
+ // InternalOXtype.g:15038:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1());
+ }
+ // InternalOXtype.g:15039:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 )
+ // InternalOXtype.g:15039:3: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group__0"
+ // InternalOXtype.g:15048:1: rule__JvmParameterizedTypeReference__Group__0 : rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1 ;
+ public final void rule__JvmParameterizedTypeReference__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15052:1: ( rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1 )
+ // InternalOXtype.g:15053:2: rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1
+ {
+ pushFollow(FOLLOW_22);
+ rule__JvmParameterizedTypeReference__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group__0"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group__0__Impl"
+ // InternalOXtype.g:15060:1: rule__JvmParameterizedTypeReference__Group__0__Impl : ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) ;
+ public final void rule__JvmParameterizedTypeReference__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15064:1: ( ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) )
+ // InternalOXtype.g:15065:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) )
+ {
+ // InternalOXtype.g:15065:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) )
+ // InternalOXtype.g:15066:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0());
+ }
+ // InternalOXtype.g:15067:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_0 )
+ // InternalOXtype.g:15067:3: rule__JvmParameterizedTypeReference__TypeAssignment_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__TypeAssignment_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group__0__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group__1"
+ // InternalOXtype.g:15075:1: rule__JvmParameterizedTypeReference__Group__1 : rule__JvmParameterizedTypeReference__Group__1__Impl ;
+ public final void rule__JvmParameterizedTypeReference__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15079:1: ( rule__JvmParameterizedTypeReference__Group__1__Impl )
+ // InternalOXtype.g:15080:2: rule__JvmParameterizedTypeReference__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group__1"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group__1__Impl"
+ // InternalOXtype.g:15086:1: rule__JvmParameterizedTypeReference__Group__1__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) ;
+ public final void rule__JvmParameterizedTypeReference__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15090:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) )
+ // InternalOXtype.g:15091:1: ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? )
+ {
+ // InternalOXtype.g:15091:1: ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? )
+ // InternalOXtype.g:15092:2: ( rule__JvmParameterizedTypeReference__Group_1__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1());
+ }
+ // InternalOXtype.g:15093:2: ( rule__JvmParameterizedTypeReference__Group_1__0 )?
+ int alt122=2;
+ alt122 = dfa122.predict(input);
+ switch (alt122) {
+ case 1 :
+ // InternalOXtype.g:15093:3: rule__JvmParameterizedTypeReference__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group__1__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__0"
+ // InternalOXtype.g:15102:1: rule__JvmParameterizedTypeReference__Group_1__0 : rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1 ;
+ public final void rule__JvmParameterizedTypeReference__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15106:1: ( rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1 )
+ // InternalOXtype.g:15107:2: rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1
+ {
+ pushFollow(FOLLOW_52);
+ rule__JvmParameterizedTypeReference__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__0"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__0__Impl"
+ // InternalOXtype.g:15114:1: rule__JvmParameterizedTypeReference__Group_1__0__Impl : ( ( '<' ) ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15118:1: ( ( ( '<' ) ) )
+ // InternalOXtype.g:15119:1: ( ( '<' ) )
+ {
+ // InternalOXtype.g:15119:1: ( ( '<' ) )
+ // InternalOXtype.g:15120:2: ( '<' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0());
+ }
+ // InternalOXtype.g:15121:2: ( '<' )
+ // InternalOXtype.g:15121:3: '<'
+ {
+ match(input,27,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__1"
+ // InternalOXtype.g:15129:1: rule__JvmParameterizedTypeReference__Group_1__1 : rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2 ;
+ public final void rule__JvmParameterizedTypeReference__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15133:1: ( rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2 )
+ // InternalOXtype.g:15134:2: rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2
+ {
+ pushFollow(FOLLOW_53);
+ rule__JvmParameterizedTypeReference__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__1"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__1__Impl"
+ // InternalOXtype.g:15141:1: rule__JvmParameterizedTypeReference__Group_1__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15145:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) )
+ // InternalOXtype.g:15146:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) )
+ {
+ // InternalOXtype.g:15146:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) )
+ // InternalOXtype.g:15147:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1());
+ }
+ // InternalOXtype.g:15148:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 )
+ // InternalOXtype.g:15148:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__2"
+ // InternalOXtype.g:15156:1: rule__JvmParameterizedTypeReference__Group_1__2 : rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3 ;
+ public final void rule__JvmParameterizedTypeReference__Group_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15160:1: ( rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3 )
+ // InternalOXtype.g:15161:2: rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3
+ {
+ pushFollow(FOLLOW_53);
+ rule__JvmParameterizedTypeReference__Group_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__2"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__2__Impl"
+ // InternalOXtype.g:15168:1: rule__JvmParameterizedTypeReference__Group_1__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15172:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) )
+ // InternalOXtype.g:15173:1: ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* )
+ {
+ // InternalOXtype.g:15173:1: ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* )
+ // InternalOXtype.g:15174:2: ( rule__JvmParameterizedTypeReference__Group_1_2__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2());
+ }
+ // InternalOXtype.g:15175:2: ( rule__JvmParameterizedTypeReference__Group_1_2__0 )*
+ loop123:
+ do {
+ int alt123=2;
+ int LA123_0 = input.LA(1);
+
+ if ( (LA123_0==55) ) {
+ alt123=1;
+ }
+
+
+ switch (alt123) {
+ case 1 :
+ // InternalOXtype.g:15175:3: rule__JvmParameterizedTypeReference__Group_1_2__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__JvmParameterizedTypeReference__Group_1_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop123;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__2__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__3"
+ // InternalOXtype.g:15183:1: rule__JvmParameterizedTypeReference__Group_1__3 : rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4 ;
+ public final void rule__JvmParameterizedTypeReference__Group_1__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15187:1: ( rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4 )
+ // InternalOXtype.g:15188:2: rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4
+ {
+ pushFollow(FOLLOW_94);
+ rule__JvmParameterizedTypeReference__Group_1__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__3"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__3__Impl"
+ // InternalOXtype.g:15195:1: rule__JvmParameterizedTypeReference__Group_1__3__Impl : ( '>' ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15199:1: ( ( '>' ) )
+ // InternalOXtype.g:15200:1: ( '>' )
+ {
+ // InternalOXtype.g:15200:1: ( '>' )
+ // InternalOXtype.g:15201:2: '>'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3());
+ }
+ match(input,26,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__3__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__4"
+ // InternalOXtype.g:15210:1: rule__JvmParameterizedTypeReference__Group_1__4 : rule__JvmParameterizedTypeReference__Group_1__4__Impl ;
+ public final void rule__JvmParameterizedTypeReference__Group_1__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15214:1: ( rule__JvmParameterizedTypeReference__Group_1__4__Impl )
+ // InternalOXtype.g:15215:2: rule__JvmParameterizedTypeReference__Group_1__4__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__4"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__4__Impl"
+ // InternalOXtype.g:15221:1: rule__JvmParameterizedTypeReference__Group_1__4__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15225:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) )
+ // InternalOXtype.g:15226:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* )
+ {
+ // InternalOXtype.g:15226:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* )
+ // InternalOXtype.g:15227:2: ( rule__JvmParameterizedTypeReference__Group_1_4__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4());
+ }
+ // InternalOXtype.g:15228:2: ( rule__JvmParameterizedTypeReference__Group_1_4__0 )*
+ loop124:
+ do {
+ int alt124=2;
+ int LA124_0 = input.LA(1);
+
+ if ( (LA124_0==43) ) {
+ int LA124_2 = input.LA(2);
+
+ if ( (LA124_2==RULE_ID) ) {
+ int LA124_3 = input.LA(3);
+
+ if ( (synpred168_InternalOXtype()) ) {
+ alt124=1;
+ }
+
+
+ }
+
+
+ }
+
+
+ switch (alt124) {
+ case 1 :
+ // InternalOXtype.g:15228:3: rule__JvmParameterizedTypeReference__Group_1_4__0
+ {
+ pushFollow(FOLLOW_95);
+ rule__JvmParameterizedTypeReference__Group_1_4__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop124;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__4__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__0"
+ // InternalOXtype.g:15237:1: rule__JvmParameterizedTypeReference__Group_1_2__0 : rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1 ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15241:1: ( rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1 )
+ // InternalOXtype.g:15242:2: rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1
+ {
+ pushFollow(FOLLOW_52);
+ rule__JvmParameterizedTypeReference__Group_1_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__0"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__0__Impl"
+ // InternalOXtype.g:15249:1: rule__JvmParameterizedTypeReference__Group_1_2__0__Impl : ( ',' ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15253:1: ( ( ',' ) )
+ // InternalOXtype.g:15254:1: ( ',' )
+ {
+ // InternalOXtype.g:15254:1: ( ',' )
+ // InternalOXtype.g:15255:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__0__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__1"
+ // InternalOXtype.g:15264:1: rule__JvmParameterizedTypeReference__Group_1_2__1 : rule__JvmParameterizedTypeReference__Group_1_2__1__Impl ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15268:1: ( rule__JvmParameterizedTypeReference__Group_1_2__1__Impl )
+ // InternalOXtype.g:15269:2: rule__JvmParameterizedTypeReference__Group_1_2__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__1"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__1__Impl"
+ // InternalOXtype.g:15275:1: rule__JvmParameterizedTypeReference__Group_1_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15279:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) )
+ // InternalOXtype.g:15280:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) )
+ {
+ // InternalOXtype.g:15280:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) )
+ // InternalOXtype.g:15281:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1());
+ }
+ // InternalOXtype.g:15282:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 )
+ // InternalOXtype.g:15282:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__1__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__0"
+ // InternalOXtype.g:15291:1: rule__JvmParameterizedTypeReference__Group_1_4__0 : rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1 ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15295:1: ( rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1 )
+ // InternalOXtype.g:15296:2: rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1
+ {
+ pushFollow(FOLLOW_9);
+ rule__JvmParameterizedTypeReference__Group_1_4__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_4__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__0"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__0__Impl"
+ // InternalOXtype.g:15303:1: rule__JvmParameterizedTypeReference__Group_1_4__0__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15307:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) )
+ // InternalOXtype.g:15308:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) )
+ {
+ // InternalOXtype.g:15308:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) )
+ // InternalOXtype.g:15309:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0());
+ }
+ // InternalOXtype.g:15310:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 )
+ // InternalOXtype.g:15310:3: rule__JvmParameterizedTypeReference__Group_1_4_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_4_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__0__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__1"
+ // InternalOXtype.g:15318:1: rule__JvmParameterizedTypeReference__Group_1_4__1 : rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2 ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15322:1: ( rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2 )
+ // InternalOXtype.g:15323:2: rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2
+ {
+ pushFollow(FOLLOW_22);
+ rule__JvmParameterizedTypeReference__Group_1_4__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_4__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__1"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__1__Impl"
+ // InternalOXtype.g:15330:1: rule__JvmParameterizedTypeReference__Group_1_4__1__Impl : ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15334:1: ( ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) )
+ // InternalOXtype.g:15335:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) )
+ {
+ // InternalOXtype.g:15335:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) )
+ // InternalOXtype.g:15336:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1());
+ }
+ // InternalOXtype.g:15337:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 )
+ // InternalOXtype.g:15337:3: rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__1__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__2"
+ // InternalOXtype.g:15345:1: rule__JvmParameterizedTypeReference__Group_1_4__2 : rule__JvmParameterizedTypeReference__Group_1_4__2__Impl ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15349:1: ( rule__JvmParameterizedTypeReference__Group_1_4__2__Impl )
+ // InternalOXtype.g:15350:2: rule__JvmParameterizedTypeReference__Group_1_4__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_4__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__2"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__2__Impl"
+ // InternalOXtype.g:15356:1: rule__JvmParameterizedTypeReference__Group_1_4__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15360:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) )
+ // InternalOXtype.g:15361:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? )
+ {
+ // InternalOXtype.g:15361:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? )
+ // InternalOXtype.g:15362:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2());
+ }
+ // InternalOXtype.g:15363:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )?
+ int alt125=2;
+ alt125 = dfa125.predict(input);
+ switch (alt125) {
+ case 1 :
+ // InternalOXtype.g:15363:3: rule__JvmParameterizedTypeReference__Group_1_4_2__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_4_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__2__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0__0"
+ // InternalOXtype.g:15372:1: rule__JvmParameterizedTypeReference__Group_1_4_0__0 : rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15376:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl )
+ // InternalOXtype.g:15377:2: rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0__0"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl"
+ // InternalOXtype.g:15383:1: rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15387:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) )
+ // InternalOXtype.g:15388:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) )
+ {
+ // InternalOXtype.g:15388:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) )
+ // InternalOXtype.g:15389:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0());
+ }
+ // InternalOXtype.g:15390:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 )
+ // InternalOXtype.g:15390:3: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_4_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0"
+ // InternalOXtype.g:15399:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 : rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15403:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 )
+ // InternalOXtype.g:15404:2: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1
+ {
+ pushFollow(FOLLOW_94);
+ rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_4_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl"
+ // InternalOXtype.g:15411:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl : ( () ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15415:1: ( ( () ) )
+ // InternalOXtype.g:15416:1: ( () )
+ {
+ // InternalOXtype.g:15416:1: ( () )
+ // InternalOXtype.g:15417:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0());
+ }
+ // InternalOXtype.g:15418:2: ()
+ // InternalOXtype.g:15418:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1"
+ // InternalOXtype.g:15426:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 : rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15430:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl )
+ // InternalOXtype.g:15431:2: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl"
+ // InternalOXtype.g:15437:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl : ( '.' ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15441:1: ( ( '.' ) )
+ // InternalOXtype.g:15442:1: ( '.' )
+ {
+ // InternalOXtype.g:15442:1: ( '.' )
+ // InternalOXtype.g:15443:2: '.'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1());
+ }
+ match(input,43,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__0"
+ // InternalOXtype.g:15453:1: rule__JvmParameterizedTypeReference__Group_1_4_2__0 : rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1 ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15457:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1 )
+ // InternalOXtype.g:15458:2: rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1
+ {
+ pushFollow(FOLLOW_52);
+ rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_4_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__0"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl"
+ // InternalOXtype.g:15465:1: rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl : ( ( '<' ) ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15469:1: ( ( ( '<' ) ) )
+ // InternalOXtype.g:15470:1: ( ( '<' ) )
+ {
+ // InternalOXtype.g:15470:1: ( ( '<' ) )
+ // InternalOXtype.g:15471:2: ( '<' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0());
+ }
+ // InternalOXtype.g:15472:2: ( '<' )
+ // InternalOXtype.g:15472:3: '<'
+ {
+ match(input,27,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__1"
+ // InternalOXtype.g:15480:1: rule__JvmParameterizedTypeReference__Group_1_4_2__1 : rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2 ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15484:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2 )
+ // InternalOXtype.g:15485:2: rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2
+ {
+ pushFollow(FOLLOW_53);
+ rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_4_2__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__1"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl"
+ // InternalOXtype.g:15492:1: rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15496:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) )
+ // InternalOXtype.g:15497:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) )
+ {
+ // InternalOXtype.g:15497:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) )
+ // InternalOXtype.g:15498:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1());
+ }
+ // InternalOXtype.g:15499:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 )
+ // InternalOXtype.g:15499:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__2"
+ // InternalOXtype.g:15507:1: rule__JvmParameterizedTypeReference__Group_1_4_2__2 : rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3 ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_2__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15511:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3 )
+ // InternalOXtype.g:15512:2: rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3
+ {
+ pushFollow(FOLLOW_53);
+ rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_4_2__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__2"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl"
+ // InternalOXtype.g:15519:1: rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15523:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) )
+ // InternalOXtype.g:15524:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* )
+ {
+ // InternalOXtype.g:15524:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* )
+ // InternalOXtype.g:15525:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2());
+ }
+ // InternalOXtype.g:15526:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )*
+ loop126:
+ do {
+ int alt126=2;
+ int LA126_0 = input.LA(1);
+
+ if ( (LA126_0==55) ) {
+ alt126=1;
+ }
+
+
+ switch (alt126) {
+ case 1 :
+ // InternalOXtype.g:15526:3: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0
+ {
+ pushFollow(FOLLOW_14);
+ rule__JvmParameterizedTypeReference__Group_1_4_2_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop126;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__3"
+ // InternalOXtype.g:15534:1: rule__JvmParameterizedTypeReference__Group_1_4_2__3 : rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_2__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15538:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl )
+ // InternalOXtype.g:15539:2: rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__3"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl"
+ // InternalOXtype.g:15545:1: rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl : ( '>' ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15549:1: ( ( '>' ) )
+ // InternalOXtype.g:15550:1: ( '>' )
+ {
+ // InternalOXtype.g:15550:1: ( '>' )
+ // InternalOXtype.g:15551:2: '>'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3());
+ }
+ match(input,26,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0"
+ // InternalOXtype.g:15561:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 : rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15565:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 )
+ // InternalOXtype.g:15566:2: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1
+ {
+ pushFollow(FOLLOW_52);
+ rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_4_2_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl"
+ // InternalOXtype.g:15573:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl : ( ',' ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15577:1: ( ( ',' ) )
+ // InternalOXtype.g:15578:1: ( ',' )
+ {
+ // InternalOXtype.g:15578:1: ( ',' )
+ // InternalOXtype.g:15579:2: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1"
+ // InternalOXtype.g:15588:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 : rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15592:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl )
+ // InternalOXtype.g:15593:2: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl"
+ // InternalOXtype.g:15599:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) ;
+ public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15603:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) )
+ // InternalOXtype.g:15604:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) )
+ {
+ // InternalOXtype.g:15604:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) )
+ // InternalOXtype.g:15605:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1());
+ }
+ // InternalOXtype.g:15606:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 )
+ // InternalOXtype.g:15606:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__Group__0"
+ // InternalOXtype.g:15615:1: rule__JvmWildcardTypeReference__Group__0 : rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1 ;
+ public final void rule__JvmWildcardTypeReference__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15619:1: ( rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1 )
+ // InternalOXtype.g:15620:2: rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1
+ {
+ pushFollow(FOLLOW_52);
+ rule__JvmWildcardTypeReference__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmWildcardTypeReference__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__Group__0"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__Group__0__Impl"
+ // InternalOXtype.g:15627:1: rule__JvmWildcardTypeReference__Group__0__Impl : ( () ) ;
+ public final void rule__JvmWildcardTypeReference__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15631:1: ( ( () ) )
+ // InternalOXtype.g:15632:1: ( () )
+ {
+ // InternalOXtype.g:15632:1: ( () )
+ // InternalOXtype.g:15633:2: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0());
+ }
+ // InternalOXtype.g:15634:2: ()
+ // InternalOXtype.g:15634:3:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__Group__0__Impl"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__Group__1"
+ // InternalOXtype.g:15642:1: rule__JvmWildcardTypeReference__Group__1 : rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2 ;
+ public final void rule__JvmWildcardTypeReference__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15646:1: ( rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2 )
+ // InternalOXtype.g:15647:2: rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2
+ {
+ pushFollow(FOLLOW_98);
+ rule__JvmWildcardTypeReference__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmWildcardTypeReference__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__Group__1"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__Group__1__Impl"
+ // InternalOXtype.g:15654:1: rule__JvmWildcardTypeReference__Group__1__Impl : ( '?' ) ;
+ public final void rule__JvmWildcardTypeReference__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15658:1: ( ( '?' ) )
+ // InternalOXtype.g:15659:1: ( '?' )
+ {
+ // InternalOXtype.g:15659:1: ( '?' )
+ // InternalOXtype.g:15660:2: '?'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1());
+ }
+ match(input,81,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__Group__1__Impl"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__Group__2"
+ // InternalOXtype.g:15669:1: rule__JvmWildcardTypeReference__Group__2 : rule__JvmWildcardTypeReference__Group__2__Impl ;
+ public final void rule__JvmWildcardTypeReference__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15673:1: ( rule__JvmWildcardTypeReference__Group__2__Impl )
+ // InternalOXtype.g:15674:2: rule__JvmWildcardTypeReference__Group__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmWildcardTypeReference__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__Group__2"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__Group__2__Impl"
+ // InternalOXtype.g:15680:1: rule__JvmWildcardTypeReference__Group__2__Impl : ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) ;
+ public final void rule__JvmWildcardTypeReference__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15684:1: ( ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) )
+ // InternalOXtype.g:15685:1: ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? )
+ {
+ // InternalOXtype.g:15685:1: ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? )
+ // InternalOXtype.g:15686:2: ( rule__JvmWildcardTypeReference__Alternatives_2 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2());
+ }
+ // InternalOXtype.g:15687:2: ( rule__JvmWildcardTypeReference__Alternatives_2 )?
+ int alt127=2;
+ int LA127_0 = input.LA(1);
+
+ if ( (LA127_0==45||LA127_0==49) ) {
+ alt127=1;
+ }
+ switch (alt127) {
+ case 1 :
+ // InternalOXtype.g:15687:3: rule__JvmWildcardTypeReference__Alternatives_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmWildcardTypeReference__Alternatives_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__Group__2__Impl"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__0"
+ // InternalOXtype.g:15696:1: rule__JvmWildcardTypeReference__Group_2_0__0 : rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1 ;
+ public final void rule__JvmWildcardTypeReference__Group_2_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15700:1: ( rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1 )
+ // InternalOXtype.g:15701:2: rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1
+ {
+ pushFollow(FOLLOW_99);
+ rule__JvmWildcardTypeReference__Group_2_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmWildcardTypeReference__Group_2_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__0"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__0__Impl"
+ // InternalOXtype.g:15708:1: rule__JvmWildcardTypeReference__Group_2_0__0__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) ;
+ public final void rule__JvmWildcardTypeReference__Group_2_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15712:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) )
+ // InternalOXtype.g:15713:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) )
+ {
+ // InternalOXtype.g:15713:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) )
+ // InternalOXtype.g:15714:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0());
+ }
+ // InternalOXtype.g:15715:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 )
+ // InternalOXtype.g:15715:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__0__Impl"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__1"
+ // InternalOXtype.g:15723:1: rule__JvmWildcardTypeReference__Group_2_0__1 : rule__JvmWildcardTypeReference__Group_2_0__1__Impl ;
+ public final void rule__JvmWildcardTypeReference__Group_2_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15727:1: ( rule__JvmWildcardTypeReference__Group_2_0__1__Impl )
+ // InternalOXtype.g:15728:2: rule__JvmWildcardTypeReference__Group_2_0__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmWildcardTypeReference__Group_2_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__1"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__1__Impl"
+ // InternalOXtype.g:15734:1: rule__JvmWildcardTypeReference__Group_2_0__1__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) ;
+ public final void rule__JvmWildcardTypeReference__Group_2_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15738:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) )
+ // InternalOXtype.g:15739:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* )
+ {
+ // InternalOXtype.g:15739:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* )
+ // InternalOXtype.g:15740:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1());
+ }
+ // InternalOXtype.g:15741:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )*
+ loop128:
+ do {
+ int alt128=2;
+ int LA128_0 = input.LA(1);
+
+ if ( (LA128_0==82) ) {
+ alt128=1;
+ }
+
+
+ switch (alt128) {
+ case 1 :
+ // InternalOXtype.g:15741:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1
+ {
+ pushFollow(FOLLOW_100);
+ rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop128;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__1__Impl"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__0"
+ // InternalOXtype.g:15750:1: rule__JvmWildcardTypeReference__Group_2_1__0 : rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1 ;
+ public final void rule__JvmWildcardTypeReference__Group_2_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15754:1: ( rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1 )
+ // InternalOXtype.g:15755:2: rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1
+ {
+ pushFollow(FOLLOW_99);
+ rule__JvmWildcardTypeReference__Group_2_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmWildcardTypeReference__Group_2_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__0"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__0__Impl"
+ // InternalOXtype.g:15762:1: rule__JvmWildcardTypeReference__Group_2_1__0__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) ;
+ public final void rule__JvmWildcardTypeReference__Group_2_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15766:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) )
+ // InternalOXtype.g:15767:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) )
+ {
+ // InternalOXtype.g:15767:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) )
+ // InternalOXtype.g:15768:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0());
+ }
+ // InternalOXtype.g:15769:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 )
+ // InternalOXtype.g:15769:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__0__Impl"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__1"
+ // InternalOXtype.g:15777:1: rule__JvmWildcardTypeReference__Group_2_1__1 : rule__JvmWildcardTypeReference__Group_2_1__1__Impl ;
+ public final void rule__JvmWildcardTypeReference__Group_2_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15781:1: ( rule__JvmWildcardTypeReference__Group_2_1__1__Impl )
+ // InternalOXtype.g:15782:2: rule__JvmWildcardTypeReference__Group_2_1__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmWildcardTypeReference__Group_2_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__1"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__1__Impl"
+ // InternalOXtype.g:15788:1: rule__JvmWildcardTypeReference__Group_2_1__1__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) ;
+ public final void rule__JvmWildcardTypeReference__Group_2_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15792:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) )
+ // InternalOXtype.g:15793:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* )
+ {
+ // InternalOXtype.g:15793:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* )
+ // InternalOXtype.g:15794:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1());
+ }
+ // InternalOXtype.g:15795:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )*
+ loop129:
+ do {
+ int alt129=2;
+ int LA129_0 = input.LA(1);
+
+ if ( (LA129_0==82) ) {
+ alt129=1;
+ }
+
+
+ switch (alt129) {
+ case 1 :
+ // InternalOXtype.g:15795:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1
+ {
+ pushFollow(FOLLOW_100);
+ rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop129;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__1__Impl"
+
+
+ // $ANTLR start "rule__JvmUpperBound__Group__0"
+ // InternalOXtype.g:15804:1: rule__JvmUpperBound__Group__0 : rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1 ;
+ public final void rule__JvmUpperBound__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15808:1: ( rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1 )
+ // InternalOXtype.g:15809:2: rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1
+ {
+ pushFollow(FOLLOW_32);
+ rule__JvmUpperBound__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmUpperBound__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmUpperBound__Group__0"
+
+
+ // $ANTLR start "rule__JvmUpperBound__Group__0__Impl"
+ // InternalOXtype.g:15816:1: rule__JvmUpperBound__Group__0__Impl : ( 'extends' ) ;
+ public final void rule__JvmUpperBound__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15820:1: ( ( 'extends' ) )
+ // InternalOXtype.g:15821:1: ( 'extends' )
+ {
+ // InternalOXtype.g:15821:1: ( 'extends' )
+ // InternalOXtype.g:15822:2: 'extends'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0());
+ }
+ match(input,45,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmUpperBound__Group__0__Impl"
+
+
+ // $ANTLR start "rule__JvmUpperBound__Group__1"
+ // InternalOXtype.g:15831:1: rule__JvmUpperBound__Group__1 : rule__JvmUpperBound__Group__1__Impl ;
+ public final void rule__JvmUpperBound__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15835:1: ( rule__JvmUpperBound__Group__1__Impl )
+ // InternalOXtype.g:15836:2: rule__JvmUpperBound__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmUpperBound__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmUpperBound__Group__1"
+
+
+ // $ANTLR start "rule__JvmUpperBound__Group__1__Impl"
+ // InternalOXtype.g:15842:1: rule__JvmUpperBound__Group__1__Impl : ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) ;
+ public final void rule__JvmUpperBound__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15846:1: ( ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) )
+ // InternalOXtype.g:15847:1: ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) )
+ {
+ // InternalOXtype.g:15847:1: ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) )
+ // InternalOXtype.g:15848:2: ( rule__JvmUpperBound__TypeReferenceAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1());
+ }
+ // InternalOXtype.g:15849:2: ( rule__JvmUpperBound__TypeReferenceAssignment_1 )
+ // InternalOXtype.g:15849:3: rule__JvmUpperBound__TypeReferenceAssignment_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmUpperBound__TypeReferenceAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmUpperBound__Group__1__Impl"
+
+
+ // $ANTLR start "rule__JvmUpperBoundAnded__Group__0"
+ // InternalOXtype.g:15858:1: rule__JvmUpperBoundAnded__Group__0 : rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1 ;
+ public final void rule__JvmUpperBoundAnded__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15862:1: ( rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1 )
+ // InternalOXtype.g:15863:2: rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1
+ {
+ pushFollow(FOLLOW_32);
+ rule__JvmUpperBoundAnded__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmUpperBoundAnded__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmUpperBoundAnded__Group__0"
+
+
+ // $ANTLR start "rule__JvmUpperBoundAnded__Group__0__Impl"
+ // InternalOXtype.g:15870:1: rule__JvmUpperBoundAnded__Group__0__Impl : ( '&' ) ;
+ public final void rule__JvmUpperBoundAnded__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15874:1: ( ( '&' ) )
+ // InternalOXtype.g:15875:1: ( '&' )
+ {
+ // InternalOXtype.g:15875:1: ( '&' )
+ // InternalOXtype.g:15876:2: '&'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0());
+ }
+ match(input,82,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmUpperBoundAnded__Group__0__Impl"
+
+
+ // $ANTLR start "rule__JvmUpperBoundAnded__Group__1"
+ // InternalOXtype.g:15885:1: rule__JvmUpperBoundAnded__Group__1 : rule__JvmUpperBoundAnded__Group__1__Impl ;
+ public final void rule__JvmUpperBoundAnded__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15889:1: ( rule__JvmUpperBoundAnded__Group__1__Impl )
+ // InternalOXtype.g:15890:2: rule__JvmUpperBoundAnded__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmUpperBoundAnded__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmUpperBoundAnded__Group__1"
+
+
+ // $ANTLR start "rule__JvmUpperBoundAnded__Group__1__Impl"
+ // InternalOXtype.g:15896:1: rule__JvmUpperBoundAnded__Group__1__Impl : ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) ;
+ public final void rule__JvmUpperBoundAnded__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15900:1: ( ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) )
+ // InternalOXtype.g:15901:1: ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) )
+ {
+ // InternalOXtype.g:15901:1: ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) )
+ // InternalOXtype.g:15902:2: ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1());
+ }
+ // InternalOXtype.g:15903:2: ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 )
+ // InternalOXtype.g:15903:3: rule__JvmUpperBoundAnded__TypeReferenceAssignment_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmUpperBoundAnded__TypeReferenceAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmUpperBoundAnded__Group__1__Impl"
+
+
+ // $ANTLR start "rule__JvmLowerBound__Group__0"
+ // InternalOXtype.g:15912:1: rule__JvmLowerBound__Group__0 : rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1 ;
+ public final void rule__JvmLowerBound__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15916:1: ( rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1 )
+ // InternalOXtype.g:15917:2: rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1
+ {
+ pushFollow(FOLLOW_32);
+ rule__JvmLowerBound__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmLowerBound__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmLowerBound__Group__0"
+
+
+ // $ANTLR start "rule__JvmLowerBound__Group__0__Impl"
+ // InternalOXtype.g:15924:1: rule__JvmLowerBound__Group__0__Impl : ( 'super' ) ;
+ public final void rule__JvmLowerBound__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15928:1: ( ( 'super' ) )
+ // InternalOXtype.g:15929:1: ( 'super' )
+ {
+ // InternalOXtype.g:15929:1: ( 'super' )
+ // InternalOXtype.g:15930:2: 'super'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0());
+ }
+ match(input,49,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmLowerBound__Group__0__Impl"
+
+
+ // $ANTLR start "rule__JvmLowerBound__Group__1"
+ // InternalOXtype.g:15939:1: rule__JvmLowerBound__Group__1 : rule__JvmLowerBound__Group__1__Impl ;
+ public final void rule__JvmLowerBound__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15943:1: ( rule__JvmLowerBound__Group__1__Impl )
+ // InternalOXtype.g:15944:2: rule__JvmLowerBound__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmLowerBound__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmLowerBound__Group__1"
+
+
+ // $ANTLR start "rule__JvmLowerBound__Group__1__Impl"
+ // InternalOXtype.g:15950:1: rule__JvmLowerBound__Group__1__Impl : ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) ;
+ public final void rule__JvmLowerBound__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15954:1: ( ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) )
+ // InternalOXtype.g:15955:1: ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) )
+ {
+ // InternalOXtype.g:15955:1: ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) )
+ // InternalOXtype.g:15956:2: ( rule__JvmLowerBound__TypeReferenceAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1());
+ }
+ // InternalOXtype.g:15957:2: ( rule__JvmLowerBound__TypeReferenceAssignment_1 )
+ // InternalOXtype.g:15957:3: rule__JvmLowerBound__TypeReferenceAssignment_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmLowerBound__TypeReferenceAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmLowerBound__Group__1__Impl"
+
+
+ // $ANTLR start "rule__JvmLowerBoundAnded__Group__0"
+ // InternalOXtype.g:15966:1: rule__JvmLowerBoundAnded__Group__0 : rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1 ;
+ public final void rule__JvmLowerBoundAnded__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15970:1: ( rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1 )
+ // InternalOXtype.g:15971:2: rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1
+ {
+ pushFollow(FOLLOW_32);
+ rule__JvmLowerBoundAnded__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__JvmLowerBoundAnded__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmLowerBoundAnded__Group__0"
+
+
+ // $ANTLR start "rule__JvmLowerBoundAnded__Group__0__Impl"
+ // InternalOXtype.g:15978:1: rule__JvmLowerBoundAnded__Group__0__Impl : ( '&' ) ;
+ public final void rule__JvmLowerBoundAnded__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15982:1: ( ( '&' ) )
+ // InternalOXtype.g:15983:1: ( '&' )
+ {
+ // InternalOXtype.g:15983:1: ( '&' )
+ // InternalOXtype.g:15984:2: '&'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0());
+ }
+ match(input,82,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmLowerBoundAnded__Group__0__Impl"
+
+
+ // $ANTLR start "rule__JvmLowerBoundAnded__Group__1"
+ // InternalOXtype.g:15993:1: rule__JvmLowerBoundAnded__Group__1 : rule__JvmLowerBoundAnded__Group__1__Impl ;
+ public final void rule__JvmLowerBoundAnded__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:15997:1: ( rule__JvmLowerBoundAnded__Group__1__Impl )
+ // InternalOXtype.g:15998:2: rule__JvmLowerBoundAnded__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmLowerBoundAnded__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmLowerBoundAnded__Group__1"
+
+
+ // $ANTLR start "rule__JvmLowerBoundAnded__Group__1__Impl"
+ // InternalOXtype.g:16004:1: rule__JvmLowerBoundAnded__Group__1__Impl : ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) ;
+ public final void rule__JvmLowerBoundAnded__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16008:1: ( ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) )
+ // InternalOXtype.g:16009:1: ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) )
+ {
+ // InternalOXtype.g:16009:1: ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) )
+ // InternalOXtype.g:16010:2: ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1());
+ }
+ // InternalOXtype.g:16011:2: ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 )
+ // InternalOXtype.g:16011:3: rule__JvmLowerBoundAnded__TypeReferenceAssignment_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmLowerBoundAnded__TypeReferenceAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmLowerBoundAnded__Group__1__Impl"
+
+
+ // $ANTLR start "rule__QualifiedNameWithWildcard__Group__0"
+ // InternalOXtype.g:16020:1: rule__QualifiedNameWithWildcard__Group__0 : rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 ;
+ public final void rule__QualifiedNameWithWildcard__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16024:1: ( rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 )
+ // InternalOXtype.g:16025:2: rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1
+ {
+ pushFollow(FOLLOW_94);
+ rule__QualifiedNameWithWildcard__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__QualifiedNameWithWildcard__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedNameWithWildcard__Group__0"
+
+
+ // $ANTLR start "rule__QualifiedNameWithWildcard__Group__0__Impl"
+ // InternalOXtype.g:16032:1: rule__QualifiedNameWithWildcard__Group__0__Impl : ( ruleQualifiedName ) ;
+ public final void rule__QualifiedNameWithWildcard__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16036:1: ( ( ruleQualifiedName ) )
+ // InternalOXtype.g:16037:1: ( ruleQualifiedName )
+ {
+ // InternalOXtype.g:16037:1: ( ruleQualifiedName )
+ // InternalOXtype.g:16038:2: ruleQualifiedName
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleQualifiedName();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedNameWithWildcard__Group__0__Impl"
+
+
+ // $ANTLR start "rule__QualifiedNameWithWildcard__Group__1"
+ // InternalOXtype.g:16047:1: rule__QualifiedNameWithWildcard__Group__1 : rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2 ;
+ public final void rule__QualifiedNameWithWildcard__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16051:1: ( rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2 )
+ // InternalOXtype.g:16052:2: rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2
+ {
+ pushFollow(FOLLOW_101);
+ rule__QualifiedNameWithWildcard__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__QualifiedNameWithWildcard__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedNameWithWildcard__Group__1"
+
+
+ // $ANTLR start "rule__QualifiedNameWithWildcard__Group__1__Impl"
+ // InternalOXtype.g:16059:1: rule__QualifiedNameWithWildcard__Group__1__Impl : ( '.' ) ;
+ public final void rule__QualifiedNameWithWildcard__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16063:1: ( ( '.' ) )
+ // InternalOXtype.g:16064:1: ( '.' )
+ {
+ // InternalOXtype.g:16064:1: ( '.' )
+ // InternalOXtype.g:16065:2: '.'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1());
+ }
+ match(input,43,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedNameWithWildcard__Group__1__Impl"
+
+
+ // $ANTLR start "rule__QualifiedNameWithWildcard__Group__2"
+ // InternalOXtype.g:16074:1: rule__QualifiedNameWithWildcard__Group__2 : rule__QualifiedNameWithWildcard__Group__2__Impl ;
+ public final void rule__QualifiedNameWithWildcard__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16078:1: ( rule__QualifiedNameWithWildcard__Group__2__Impl )
+ // InternalOXtype.g:16079:2: rule__QualifiedNameWithWildcard__Group__2__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__QualifiedNameWithWildcard__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedNameWithWildcard__Group__2"
+
+
+ // $ANTLR start "rule__QualifiedNameWithWildcard__Group__2__Impl"
+ // InternalOXtype.g:16085:1: rule__QualifiedNameWithWildcard__Group__2__Impl : ( '*' ) ;
+ public final void rule__QualifiedNameWithWildcard__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16089:1: ( ( '*' ) )
+ // InternalOXtype.g:16090:1: ( '*' )
+ {
+ // InternalOXtype.g:16090:1: ( '*' )
+ // InternalOXtype.g:16091:2: '*'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2());
+ }
+ match(input,36,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedNameWithWildcard__Group__2__Impl"
+
+
+ // $ANTLR start "rule__QualifiedNameInStaticImport__Group__0"
+ // InternalOXtype.g:16101:1: rule__QualifiedNameInStaticImport__Group__0 : rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1 ;
+ public final void rule__QualifiedNameInStaticImport__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16105:1: ( rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1 )
+ // InternalOXtype.g:16106:2: rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1
+ {
+ pushFollow(FOLLOW_94);
+ rule__QualifiedNameInStaticImport__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_2);
+ rule__QualifiedNameInStaticImport__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedNameInStaticImport__Group__0"
+
+
+ // $ANTLR start "rule__QualifiedNameInStaticImport__Group__0__Impl"
+ // InternalOXtype.g:16113:1: rule__QualifiedNameInStaticImport__Group__0__Impl : ( ruleValidID ) ;
+ public final void rule__QualifiedNameInStaticImport__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16117:1: ( ( ruleValidID ) )
+ // InternalOXtype.g:16118:1: ( ruleValidID )
+ {
+ // InternalOXtype.g:16118:1: ( ruleValidID )
+ // InternalOXtype.g:16119:2: ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedNameInStaticImport__Group__0__Impl"
+
+
+ // $ANTLR start "rule__QualifiedNameInStaticImport__Group__1"
+ // InternalOXtype.g:16128:1: rule__QualifiedNameInStaticImport__Group__1 : rule__QualifiedNameInStaticImport__Group__1__Impl ;
+ public final void rule__QualifiedNameInStaticImport__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16132:1: ( rule__QualifiedNameInStaticImport__Group__1__Impl )
+ // InternalOXtype.g:16133:2: rule__QualifiedNameInStaticImport__Group__1__Impl
+ {
+ pushFollow(FOLLOW_2);
+ rule__QualifiedNameInStaticImport__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedNameInStaticImport__Group__1"
+
+
+ // $ANTLR start "rule__QualifiedNameInStaticImport__Group__1__Impl"
+ // InternalOXtype.g:16139:1: rule__QualifiedNameInStaticImport__Group__1__Impl : ( '.' ) ;
+ public final void rule__QualifiedNameInStaticImport__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16143:1: ( ( '.' ) )
+ // InternalOXtype.g:16144:1: ( '.' )
+ {
+ // InternalOXtype.g:16144:1: ( '.' )
+ // InternalOXtype.g:16145:2: '.'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1());
+ }
+ match(input,43,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__QualifiedNameInStaticImport__Group__1__Impl"
+
+
+ // $ANTLR start "rule__XImportDeclaration__StaticAssignment_2_0_0"
+ // InternalOXtype.g:16155:1: rule__XImportDeclaration__StaticAssignment_2_0_0 : ( ( 'static' ) ) ;
+ public final void rule__XImportDeclaration__StaticAssignment_2_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16159:1: ( ( ( 'static' ) ) )
+ // InternalOXtype.g:16160:2: ( ( 'static' ) )
+ {
+ // InternalOXtype.g:16160:2: ( ( 'static' ) )
+ // InternalOXtype.g:16161:3: ( 'static' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0());
+ }
+ // InternalOXtype.g:16162:3: ( 'static' )
+ // InternalOXtype.g:16163:4: 'static'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0());
+ }
+ match(input,46,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__StaticAssignment_2_0_0"
+
+
+ // $ANTLR start "rule__XImportDeclaration__ExtensionAssignment_2_0_1"
+ // InternalOXtype.g:16174:1: rule__XImportDeclaration__ExtensionAssignment_2_0_1 : ( ( 'extension' ) ) ;
+ public final void rule__XImportDeclaration__ExtensionAssignment_2_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16178:1: ( ( ( 'extension' ) ) )
+ // InternalOXtype.g:16179:2: ( ( 'extension' ) )
+ {
+ // InternalOXtype.g:16179:2: ( ( 'extension' ) )
+ // InternalOXtype.g:16180:3: ( 'extension' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0());
+ }
+ // InternalOXtype.g:16181:3: ( 'extension' )
+ // InternalOXtype.g:16182:4: 'extension'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0());
+ }
+ match(input,48,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__ExtensionAssignment_2_0_1"
+
+
+ // $ANTLR start "rule__XImportDeclaration__ImportedTypeAssignment_2_0_2"
+ // InternalOXtype.g:16193:1: rule__XImportDeclaration__ImportedTypeAssignment_2_0_2 : ( ( ruleQualifiedNameInStaticImport ) ) ;
+ public final void rule__XImportDeclaration__ImportedTypeAssignment_2_0_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16197:1: ( ( ( ruleQualifiedNameInStaticImport ) ) )
+ // InternalOXtype.g:16198:2: ( ( ruleQualifiedNameInStaticImport ) )
+ {
+ // InternalOXtype.g:16198:2: ( ( ruleQualifiedNameInStaticImport ) )
+ // InternalOXtype.g:16199:3: ( ruleQualifiedNameInStaticImport )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0());
+ }
+ // InternalOXtype.g:16200:3: ( ruleQualifiedNameInStaticImport )
+ // InternalOXtype.g:16201:4: ruleQualifiedNameInStaticImport
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_2_0_2_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleQualifiedNameInStaticImport();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_2_0_2_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__ImportedTypeAssignment_2_0_2"
+
+
+ // $ANTLR start "rule__XImportDeclaration__WildcardAssignment_2_0_3_0"
+ // InternalOXtype.g:16212:1: rule__XImportDeclaration__WildcardAssignment_2_0_3_0 : ( ( '*' ) ) ;
+ public final void rule__XImportDeclaration__WildcardAssignment_2_0_3_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16216:1: ( ( ( '*' ) ) )
+ // InternalOXtype.g:16217:2: ( ( '*' ) )
+ {
+ // InternalOXtype.g:16217:2: ( ( '*' ) )
+ // InternalOXtype.g:16218:3: ( '*' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0());
+ }
+ // InternalOXtype.g:16219:3: ( '*' )
+ // InternalOXtype.g:16220:4: '*'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0());
+ }
+ match(input,36,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__WildcardAssignment_2_0_3_0"
+
+
+ // $ANTLR start "rule__XImportDeclaration__MemberNameAssignment_2_0_3_1"
+ // InternalOXtype.g:16231:1: rule__XImportDeclaration__MemberNameAssignment_2_0_3_1 : ( ruleValidID ) ;
+ public final void rule__XImportDeclaration__MemberNameAssignment_2_0_3_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16235:1: ( ( ruleValidID ) )
+ // InternalOXtype.g:16236:2: ( ruleValidID )
+ {
+ // InternalOXtype.g:16236:2: ( ruleValidID )
+ // InternalOXtype.g:16237:3: ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_2_0_3_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_2_0_3_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__MemberNameAssignment_2_0_3_1"
+
+
+ // $ANTLR start "rule__XImportDeclaration__ImportedTypeAssignment_2_1"
+ // InternalOXtype.g:16246:1: rule__XImportDeclaration__ImportedTypeAssignment_2_1 : ( ( ruleQualifiedName ) ) ;
+ public final void rule__XImportDeclaration__ImportedTypeAssignment_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16250:1: ( ( ( ruleQualifiedName ) ) )
+ // InternalOXtype.g:16251:2: ( ( ruleQualifiedName ) )
+ {
+ // InternalOXtype.g:16251:2: ( ( ruleQualifiedName ) )
+ // InternalOXtype.g:16252:3: ( ruleQualifiedName )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_1_0());
+ }
+ // InternalOXtype.g:16253:3: ( ruleQualifiedName )
+ // InternalOXtype.g:16254:4: ruleQualifiedName
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_2_1_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleQualifiedName();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_2_1_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__ImportedTypeAssignment_2_1"
+
+
+ // $ANTLR start "rule__XImportDeclaration__ImportedNamespaceAssignment_2_2"
+ // InternalOXtype.g:16265:1: rule__XImportDeclaration__ImportedNamespaceAssignment_2_2 : ( ruleQualifiedNameWithWildcard ) ;
+ public final void rule__XImportDeclaration__ImportedNamespaceAssignment_2_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16269:1: ( ( ruleQualifiedNameWithWildcard ) )
+ // InternalOXtype.g:16270:2: ( ruleQualifiedNameWithWildcard )
+ {
+ // InternalOXtype.g:16270:2: ( ruleQualifiedNameWithWildcard )
+ // InternalOXtype.g:16271:3: ruleQualifiedNameWithWildcard
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleQualifiedNameWithWildcard();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__ImportedNamespaceAssignment_2_2"
+
+
+ // $ANTLR start "rule__XImportDeclaration__FqnImportAssignment_2_3_0"
+ // InternalOXtype.g:16280:1: rule__XImportDeclaration__FqnImportAssignment_2_3_0 : ( ( 'ns' ) ) ;
+ public final void rule__XImportDeclaration__FqnImportAssignment_2_3_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16284:1: ( ( ( 'ns' ) ) )
+ // InternalOXtype.g:16285:2: ( ( 'ns' ) )
+ {
+ // InternalOXtype.g:16285:2: ( ( 'ns' ) )
+ // InternalOXtype.g:16286:3: ( 'ns' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0());
+ }
+ // InternalOXtype.g:16287:3: ( 'ns' )
+ // InternalOXtype.g:16288:4: 'ns'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0());
+ }
+ match(input,83,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__FqnImportAssignment_2_3_0"
+
+
+ // $ANTLR start "rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1"
+ // InternalOXtype.g:16299:1: rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1 : ( ruleQualifiedName ) ;
+ public final void rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16303:1: ( ( ruleQualifiedName ) )
+ // InternalOXtype.g:16304:2: ( ruleQualifiedName )
+ {
+ // InternalOXtype.g:16304:2: ( ruleQualifiedName )
+ // InternalOXtype.g:16305:3: ruleQualifiedName
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleQualifiedName();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1"
+
+
+ // $ANTLR start "rule__XAnnotation__AnnotationTypeAssignment_2"
+ // InternalOXtype.g:16314:1: rule__XAnnotation__AnnotationTypeAssignment_2 : ( ( ruleQualifiedName ) ) ;
+ public final void rule__XAnnotation__AnnotationTypeAssignment_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16318:1: ( ( ( ruleQualifiedName ) ) )
+ // InternalOXtype.g:16319:2: ( ( ruleQualifiedName ) )
+ {
+ // InternalOXtype.g:16319:2: ( ( ruleQualifiedName ) )
+ // InternalOXtype.g:16320:3: ( ruleQualifiedName )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeCrossReference_2_0());
+ }
+ // InternalOXtype.g:16321:3: ( ruleQualifiedName )
+ // InternalOXtype.g:16322:4: ruleQualifiedName
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeQualifiedNameParserRuleCall_2_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleQualifiedName();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeQualifiedNameParserRuleCall_2_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeCrossReference_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__AnnotationTypeAssignment_2"
+
+
+ // $ANTLR start "rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0"
+ // InternalOXtype.g:16333:1: rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0 : ( ruleXAnnotationElementValuePair ) ;
+ public final void rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16337:1: ( ( ruleXAnnotationElementValuePair ) )
+ // InternalOXtype.g:16338:2: ( ruleXAnnotationElementValuePair )
+ {
+ // InternalOXtype.g:16338:2: ( ruleXAnnotationElementValuePair )
+ // InternalOXtype.g:16339:3: ruleXAnnotationElementValuePair
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAnnotationElementValuePair();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0"
+
+
+ // $ANTLR start "rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1"
+ // InternalOXtype.g:16348:1: rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1 : ( ruleXAnnotationElementValuePair ) ;
+ public final void rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16352:1: ( ( ruleXAnnotationElementValuePair ) )
+ // InternalOXtype.g:16353:2: ( ruleXAnnotationElementValuePair )
+ {
+ // InternalOXtype.g:16353:2: ( ruleXAnnotationElementValuePair )
+ // InternalOXtype.g:16354:3: ruleXAnnotationElementValuePair
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAnnotationElementValuePair();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1"
+
+
+ // $ANTLR start "rule__XAnnotation__ValueAssignment_3_1_1"
+ // InternalOXtype.g:16363:1: rule__XAnnotation__ValueAssignment_3_1_1 : ( ruleXAnnotationElementValueOrCommaList ) ;
+ public final void rule__XAnnotation__ValueAssignment_3_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16367:1: ( ( ruleXAnnotationElementValueOrCommaList ) )
+ // InternalOXtype.g:16368:2: ( ruleXAnnotationElementValueOrCommaList )
+ {
+ // InternalOXtype.g:16368:2: ( ruleXAnnotationElementValueOrCommaList )
+ // InternalOXtype.g:16369:3: ruleXAnnotationElementValueOrCommaList
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getValueXAnnotationElementValueOrCommaListParserRuleCall_3_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAnnotationElementValueOrCommaList();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationAccess().getValueXAnnotationElementValueOrCommaListParserRuleCall_3_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotation__ValueAssignment_3_1_1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValuePair__ElementAssignment_0_0_0"
+ // InternalOXtype.g:16378:1: rule__XAnnotationElementValuePair__ElementAssignment_0_0_0 : ( ( ruleValidID ) ) ;
+ public final void rule__XAnnotationElementValuePair__ElementAssignment_0_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16382:1: ( ( ( ruleValidID ) ) )
+ // InternalOXtype.g:16383:2: ( ( ruleValidID ) )
+ {
+ // InternalOXtype.g:16383:2: ( ( ruleValidID ) )
+ // InternalOXtype.g:16384:3: ( ruleValidID )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationCrossReference_0_0_0_0());
+ }
+ // InternalOXtype.g:16385:3: ( ruleValidID )
+ // InternalOXtype.g:16386:4: ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationValidIDParserRuleCall_0_0_0_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationValidIDParserRuleCall_0_0_0_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationCrossReference_0_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValuePair__ElementAssignment_0_0_0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValuePair__ValueAssignment_1"
+ // InternalOXtype.g:16397:1: rule__XAnnotationElementValuePair__ValueAssignment_1 : ( ruleXAnnotationElementValue ) ;
+ public final void rule__XAnnotationElementValuePair__ValueAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16401:1: ( ( ruleXAnnotationElementValue ) )
+ // InternalOXtype.g:16402:2: ( ruleXAnnotationElementValue )
+ {
+ // InternalOXtype.g:16402:2: ( ruleXAnnotationElementValue )
+ // InternalOXtype.g:16403:3: ruleXAnnotationElementValue
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValuePairAccess().getValueXAnnotationElementValueParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAnnotationElementValue();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValuePairAccess().getValueXAnnotationElementValueParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValuePair__ValueAssignment_1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0"
+ // InternalOXtype.g:16412:1: rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0 : ( ruleXAnnotationOrExpression ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16416:1: ( ( ruleXAnnotationOrExpression ) )
+ // InternalOXtype.g:16417:2: ( ruleXAnnotationOrExpression )
+ {
+ // InternalOXtype.g:16417:2: ( ruleXAnnotationOrExpression )
+ // InternalOXtype.g:16418:3: ruleXAnnotationOrExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAnnotationOrExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1"
+ // InternalOXtype.g:16427:1: rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1 : ( ruleXAnnotationOrExpression ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16431:1: ( ( ruleXAnnotationOrExpression ) )
+ // InternalOXtype.g:16432:2: ( ruleXAnnotationOrExpression )
+ {
+ // InternalOXtype.g:16432:2: ( ruleXAnnotationOrExpression )
+ // InternalOXtype.g:16433:3: ruleXAnnotationOrExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAnnotationOrExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1"
+ // InternalOXtype.g:16442:1: rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1 : ( ruleXAnnotationOrExpression ) ;
+ public final void rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16446:1: ( ( ruleXAnnotationOrExpression ) )
+ // InternalOXtype.g:16447:2: ( ruleXAnnotationOrExpression )
+ {
+ // InternalOXtype.g:16447:2: ( ruleXAnnotationOrExpression )
+ // InternalOXtype.g:16448:3: ruleXAnnotationOrExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_1_1_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAnnotationOrExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_1_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__ElementsAssignment_0_1_0"
+ // InternalOXtype.g:16457:1: rule__XAnnotationElementValue__ElementsAssignment_0_1_0 : ( ruleXAnnotationOrExpression ) ;
+ public final void rule__XAnnotationElementValue__ElementsAssignment_0_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16461:1: ( ( ruleXAnnotationOrExpression ) )
+ // InternalOXtype.g:16462:2: ( ruleXAnnotationOrExpression )
+ {
+ // InternalOXtype.g:16462:2: ( ruleXAnnotationOrExpression )
+ // InternalOXtype.g:16463:3: ruleXAnnotationOrExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAnnotationOrExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__ElementsAssignment_0_1_0"
+
+
+ // $ANTLR start "rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1"
+ // InternalOXtype.g:16472:1: rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1 : ( ruleXAnnotationOrExpression ) ;
+ public final void rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16476:1: ( ( ruleXAnnotationOrExpression ) )
+ // InternalOXtype.g:16477:2: ( ruleXAnnotationOrExpression )
+ {
+ // InternalOXtype.g:16477:2: ( ruleXAnnotationOrExpression )
+ // InternalOXtype.g:16478:3: ruleXAnnotationOrExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAnnotationOrExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1"
+
+
+ // $ANTLR start "rule__XAssignment__FeatureAssignment_0_1"
+ // InternalOXtype.g:16487:1: rule__XAssignment__FeatureAssignment_0_1 : ( ( ruleFeatureCallID ) ) ;
+ public final void rule__XAssignment__FeatureAssignment_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16491:1: ( ( ( ruleFeatureCallID ) ) )
+ // InternalOXtype.g:16492:2: ( ( ruleFeatureCallID ) )
+ {
+ // InternalOXtype.g:16492:2: ( ( ruleFeatureCallID ) )
+ // InternalOXtype.g:16493:3: ( ruleFeatureCallID )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0());
+ }
+ // InternalOXtype.g:16494:3: ( ruleFeatureCallID )
+ // InternalOXtype.g:16495:4: ruleFeatureCallID
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleFeatureCallID();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__FeatureAssignment_0_1"
+
+
+ // $ANTLR start "rule__XAssignment__ValueAssignment_0_3"
+ // InternalOXtype.g:16506:1: rule__XAssignment__ValueAssignment_0_3 : ( ruleXAssignment ) ;
+ public final void rule__XAssignment__ValueAssignment_0_3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16510:1: ( ( ruleXAssignment ) )
+ // InternalOXtype.g:16511:2: ( ruleXAssignment )
+ {
+ // InternalOXtype.g:16511:2: ( ruleXAssignment )
+ // InternalOXtype.g:16512:3: ruleXAssignment
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAssignment();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__ValueAssignment_0_3"
+
+
+ // $ANTLR start "rule__XAssignment__FeatureAssignment_1_1_0_0_1"
+ // InternalOXtype.g:16521:1: rule__XAssignment__FeatureAssignment_1_1_0_0_1 : ( ( ruleOpMultiAssign ) ) ;
+ public final void rule__XAssignment__FeatureAssignment_1_1_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16525:1: ( ( ( ruleOpMultiAssign ) ) )
+ // InternalOXtype.g:16526:2: ( ( ruleOpMultiAssign ) )
+ {
+ // InternalOXtype.g:16526:2: ( ( ruleOpMultiAssign ) )
+ // InternalOXtype.g:16527:3: ( ruleOpMultiAssign )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0());
+ }
+ // InternalOXtype.g:16528:3: ( ruleOpMultiAssign )
+ // InternalOXtype.g:16529:4: ruleOpMultiAssign
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleOpMultiAssign();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__FeatureAssignment_1_1_0_0_1"
+
+
+ // $ANTLR start "rule__XAssignment__RightOperandAssignment_1_1_1"
+ // InternalOXtype.g:16540:1: rule__XAssignment__RightOperandAssignment_1_1_1 : ( ruleXAssignment ) ;
+ public final void rule__XAssignment__RightOperandAssignment_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16544:1: ( ( ruleXAssignment ) )
+ // InternalOXtype.g:16545:2: ( ruleXAssignment )
+ {
+ // InternalOXtype.g:16545:2: ( ruleXAssignment )
+ // InternalOXtype.g:16546:3: ruleXAssignment
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAssignment();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAssignment__RightOperandAssignment_1_1_1"
+
+
+ // $ANTLR start "rule__XOrExpression__FeatureAssignment_1_0_0_1"
+ // InternalOXtype.g:16555:1: rule__XOrExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpOr ) ) ;
+ public final void rule__XOrExpression__FeatureAssignment_1_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16559:1: ( ( ( ruleOpOr ) ) )
+ // InternalOXtype.g:16560:2: ( ( ruleOpOr ) )
+ {
+ // InternalOXtype.g:16560:2: ( ( ruleOpOr ) )
+ // InternalOXtype.g:16561:3: ( ruleOpOr )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ // InternalOXtype.g:16562:3: ( ruleOpOr )
+ // InternalOXtype.g:16563:4: ruleOpOr
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleOpOr();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOrExpression__FeatureAssignment_1_0_0_1"
+
+
+ // $ANTLR start "rule__XOrExpression__RightOperandAssignment_1_1"
+ // InternalOXtype.g:16574:1: rule__XOrExpression__RightOperandAssignment_1_1 : ( ruleXAndExpression ) ;
+ public final void rule__XOrExpression__RightOperandAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16578:1: ( ( ruleXAndExpression ) )
+ // InternalOXtype.g:16579:2: ( ruleXAndExpression )
+ {
+ // InternalOXtype.g:16579:2: ( ruleXAndExpression )
+ // InternalOXtype.g:16580:3: ruleXAndExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAndExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOrExpression__RightOperandAssignment_1_1"
+
+
+ // $ANTLR start "rule__XAndExpression__FeatureAssignment_1_0_0_1"
+ // InternalOXtype.g:16589:1: rule__XAndExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpAnd ) ) ;
+ public final void rule__XAndExpression__FeatureAssignment_1_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16593:1: ( ( ( ruleOpAnd ) ) )
+ // InternalOXtype.g:16594:2: ( ( ruleOpAnd ) )
+ {
+ // InternalOXtype.g:16594:2: ( ( ruleOpAnd ) )
+ // InternalOXtype.g:16595:3: ( ruleOpAnd )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ // InternalOXtype.g:16596:3: ( ruleOpAnd )
+ // InternalOXtype.g:16597:4: ruleOpAnd
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleOpAnd();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAndExpression__FeatureAssignment_1_0_0_1"
+
+
+ // $ANTLR start "rule__XAndExpression__RightOperandAssignment_1_1"
+ // InternalOXtype.g:16608:1: rule__XAndExpression__RightOperandAssignment_1_1 : ( ruleXEqualityExpression ) ;
+ public final void rule__XAndExpression__RightOperandAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16612:1: ( ( ruleXEqualityExpression ) )
+ // InternalOXtype.g:16613:2: ( ruleXEqualityExpression )
+ {
+ // InternalOXtype.g:16613:2: ( ruleXEqualityExpression )
+ // InternalOXtype.g:16614:3: ruleXEqualityExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXEqualityExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAndExpression__RightOperandAssignment_1_1"
+
+
+ // $ANTLR start "rule__XEqualityExpression__FeatureAssignment_1_0_0_1"
+ // InternalOXtype.g:16623:1: rule__XEqualityExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpEquality ) ) ;
+ public final void rule__XEqualityExpression__FeatureAssignment_1_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16627:1: ( ( ( ruleOpEquality ) ) )
+ // InternalOXtype.g:16628:2: ( ( ruleOpEquality ) )
+ {
+ // InternalOXtype.g:16628:2: ( ( ruleOpEquality ) )
+ // InternalOXtype.g:16629:3: ( ruleOpEquality )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ // InternalOXtype.g:16630:3: ( ruleOpEquality )
+ // InternalOXtype.g:16631:4: ruleOpEquality
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleOpEquality();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XEqualityExpression__FeatureAssignment_1_0_0_1"
+
+
+ // $ANTLR start "rule__XEqualityExpression__RightOperandAssignment_1_1"
+ // InternalOXtype.g:16642:1: rule__XEqualityExpression__RightOperandAssignment_1_1 : ( ruleXRelationalExpression ) ;
+ public final void rule__XEqualityExpression__RightOperandAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16646:1: ( ( ruleXRelationalExpression ) )
+ // InternalOXtype.g:16647:2: ( ruleXRelationalExpression )
+ {
+ // InternalOXtype.g:16647:2: ( ruleXRelationalExpression )
+ // InternalOXtype.g:16648:3: ruleXRelationalExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXRelationalExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XEqualityExpression__RightOperandAssignment_1_1"
+
+
+ // $ANTLR start "rule__XRelationalExpression__TypeAssignment_1_0_1"
+ // InternalOXtype.g:16657:1: rule__XRelationalExpression__TypeAssignment_1_0_1 : ( ruleJvmTypeReference ) ;
+ public final void rule__XRelationalExpression__TypeAssignment_1_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16661:1: ( ( ruleJvmTypeReference ) )
+ // InternalOXtype.g:16662:2: ( ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:16662:2: ( ruleJvmTypeReference )
+ // InternalOXtype.g:16663:3: ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__TypeAssignment_1_0_1"
+
+
+ // $ANTLR start "rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1"
+ // InternalOXtype.g:16672:1: rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 : ( ( ruleOpCompare ) ) ;
+ public final void rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16676:1: ( ( ( ruleOpCompare ) ) )
+ // InternalOXtype.g:16677:2: ( ( ruleOpCompare ) )
+ {
+ // InternalOXtype.g:16677:2: ( ( ruleOpCompare ) )
+ // InternalOXtype.g:16678:3: ( ruleOpCompare )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0());
+ }
+ // InternalOXtype.g:16679:3: ( ruleOpCompare )
+ // InternalOXtype.g:16680:4: ruleOpCompare
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleOpCompare();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1"
+
+
+ // $ANTLR start "rule__XRelationalExpression__RightOperandAssignment_1_1_1"
+ // InternalOXtype.g:16691:1: rule__XRelationalExpression__RightOperandAssignment_1_1_1 : ( ruleXOtherOperatorExpression ) ;
+ public final void rule__XRelationalExpression__RightOperandAssignment_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16695:1: ( ( ruleXOtherOperatorExpression ) )
+ // InternalOXtype.g:16696:2: ( ruleXOtherOperatorExpression )
+ {
+ // InternalOXtype.g:16696:2: ( ruleXOtherOperatorExpression )
+ // InternalOXtype.g:16697:3: ruleXOtherOperatorExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXOtherOperatorExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XRelationalExpression__RightOperandAssignment_1_1_1"
+
+
+ // $ANTLR start "rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1"
+ // InternalOXtype.g:16706:1: rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpOther ) ) ;
+ public final void rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16710:1: ( ( ( ruleOpOther ) ) )
+ // InternalOXtype.g:16711:2: ( ( ruleOpOther ) )
+ {
+ // InternalOXtype.g:16711:2: ( ( ruleOpOther ) )
+ // InternalOXtype.g:16712:3: ( ruleOpOther )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ // InternalOXtype.g:16713:3: ( ruleOpOther )
+ // InternalOXtype.g:16714:4: ruleOpOther
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleOpOther();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1"
+
+
+ // $ANTLR start "rule__XOtherOperatorExpression__RightOperandAssignment_1_1"
+ // InternalOXtype.g:16725:1: rule__XOtherOperatorExpression__RightOperandAssignment_1_1 : ( ruleXAdditiveExpression ) ;
+ public final void rule__XOtherOperatorExpression__RightOperandAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16729:1: ( ( ruleXAdditiveExpression ) )
+ // InternalOXtype.g:16730:2: ( ruleXAdditiveExpression )
+ {
+ // InternalOXtype.g:16730:2: ( ruleXAdditiveExpression )
+ // InternalOXtype.g:16731:3: ruleXAdditiveExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAdditiveExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XOtherOperatorExpression__RightOperandAssignment_1_1"
+
+
+ // $ANTLR start "rule__XAdditiveExpression__FeatureAssignment_1_0_0_1"
+ // InternalOXtype.g:16740:1: rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpAdd ) ) ;
+ public final void rule__XAdditiveExpression__FeatureAssignment_1_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16744:1: ( ( ( ruleOpAdd ) ) )
+ // InternalOXtype.g:16745:2: ( ( ruleOpAdd ) )
+ {
+ // InternalOXtype.g:16745:2: ( ( ruleOpAdd ) )
+ // InternalOXtype.g:16746:3: ( ruleOpAdd )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ // InternalOXtype.g:16747:3: ( ruleOpAdd )
+ // InternalOXtype.g:16748:4: ruleOpAdd
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleOpAdd();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAdditiveExpression__FeatureAssignment_1_0_0_1"
+
+
+ // $ANTLR start "rule__XAdditiveExpression__RightOperandAssignment_1_1"
+ // InternalOXtype.g:16759:1: rule__XAdditiveExpression__RightOperandAssignment_1_1 : ( ruleXMultiplicativeExpression ) ;
+ public final void rule__XAdditiveExpression__RightOperandAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16763:1: ( ( ruleXMultiplicativeExpression ) )
+ // InternalOXtype.g:16764:2: ( ruleXMultiplicativeExpression )
+ {
+ // InternalOXtype.g:16764:2: ( ruleXMultiplicativeExpression )
+ // InternalOXtype.g:16765:3: ruleXMultiplicativeExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXMultiplicativeExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XAdditiveExpression__RightOperandAssignment_1_1"
+
+
+ // $ANTLR start "rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1"
+ // InternalOXtype.g:16774:1: rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpMulti ) ) ;
+ public final void rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16778:1: ( ( ( ruleOpMulti ) ) )
+ // InternalOXtype.g:16779:2: ( ( ruleOpMulti ) )
+ {
+ // InternalOXtype.g:16779:2: ( ( ruleOpMulti ) )
+ // InternalOXtype.g:16780:3: ( ruleOpMulti )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ // InternalOXtype.g:16781:3: ( ruleOpMulti )
+ // InternalOXtype.g:16782:4: ruleOpMulti
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleOpMulti();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1"
+
+
+ // $ANTLR start "rule__XMultiplicativeExpression__RightOperandAssignment_1_1"
+ // InternalOXtype.g:16793:1: rule__XMultiplicativeExpression__RightOperandAssignment_1_1 : ( ruleXUnaryOperation ) ;
+ public final void rule__XMultiplicativeExpression__RightOperandAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16797:1: ( ( ruleXUnaryOperation ) )
+ // InternalOXtype.g:16798:2: ( ruleXUnaryOperation )
+ {
+ // InternalOXtype.g:16798:2: ( ruleXUnaryOperation )
+ // InternalOXtype.g:16799:3: ruleXUnaryOperation
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXUnaryOperation();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMultiplicativeExpression__RightOperandAssignment_1_1"
+
+
+ // $ANTLR start "rule__XUnaryOperation__FeatureAssignment_0_1"
+ // InternalOXtype.g:16808:1: rule__XUnaryOperation__FeatureAssignment_0_1 : ( ( ruleOpUnary ) ) ;
+ public final void rule__XUnaryOperation__FeatureAssignment_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16812:1: ( ( ( ruleOpUnary ) ) )
+ // InternalOXtype.g:16813:2: ( ( ruleOpUnary ) )
+ {
+ // InternalOXtype.g:16813:2: ( ( ruleOpUnary ) )
+ // InternalOXtype.g:16814:3: ( ruleOpUnary )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0());
+ }
+ // InternalOXtype.g:16815:3: ( ruleOpUnary )
+ // InternalOXtype.g:16816:4: ruleOpUnary
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleOpUnary();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XUnaryOperation__FeatureAssignment_0_1"
+
+
+ // $ANTLR start "rule__XUnaryOperation__OperandAssignment_0_2"
+ // InternalOXtype.g:16827:1: rule__XUnaryOperation__OperandAssignment_0_2 : ( ruleXUnaryOperation ) ;
+ public final void rule__XUnaryOperation__OperandAssignment_0_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16831:1: ( ( ruleXUnaryOperation ) )
+ // InternalOXtype.g:16832:2: ( ruleXUnaryOperation )
+ {
+ // InternalOXtype.g:16832:2: ( ruleXUnaryOperation )
+ // InternalOXtype.g:16833:3: ruleXUnaryOperation
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXUnaryOperation();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XUnaryOperation__OperandAssignment_0_2"
+
+
+ // $ANTLR start "rule__XCastedExpression__TypeAssignment_1_1"
+ // InternalOXtype.g:16842:1: rule__XCastedExpression__TypeAssignment_1_1 : ( ruleJvmTypeReference ) ;
+ public final void rule__XCastedExpression__TypeAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16846:1: ( ( ruleJvmTypeReference ) )
+ // InternalOXtype.g:16847:2: ( ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:16847:2: ( ruleJvmTypeReference )
+ // InternalOXtype.g:16848:3: ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCastedExpression__TypeAssignment_1_1"
+
+
+ // $ANTLR start "rule__XPostfixOperation__FeatureAssignment_1_0_1"
+ // InternalOXtype.g:16857:1: rule__XPostfixOperation__FeatureAssignment_1_0_1 : ( ( ruleOpPostfix ) ) ;
+ public final void rule__XPostfixOperation__FeatureAssignment_1_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16861:1: ( ( ( ruleOpPostfix ) ) )
+ // InternalOXtype.g:16862:2: ( ( ruleOpPostfix ) )
+ {
+ // InternalOXtype.g:16862:2: ( ( ruleOpPostfix ) )
+ // InternalOXtype.g:16863:3: ( ruleOpPostfix )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0());
+ }
+ // InternalOXtype.g:16864:3: ( ruleOpPostfix )
+ // InternalOXtype.g:16865:4: ruleOpPostfix
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleOpPostfix();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XPostfixOperation__FeatureAssignment_1_0_1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1"
+ // InternalOXtype.g:16876:1: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 : ( ( '::' ) ) ;
+ public final void rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16880:1: ( ( ( '::' ) ) )
+ // InternalOXtype.g:16881:2: ( ( '::' ) )
+ {
+ // InternalOXtype.g:16881:2: ( ( '::' ) )
+ // InternalOXtype.g:16882:3: ( '::' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0());
+ }
+ // InternalOXtype.g:16883:3: ( '::' )
+ // InternalOXtype.g:16884:4: '::'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0());
+ }
+ match(input,84,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2"
+ // InternalOXtype.g:16895:1: rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 : ( ( ruleFeatureCallID ) ) ;
+ public final void rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16899:1: ( ( ( ruleFeatureCallID ) ) )
+ // InternalOXtype.g:16900:2: ( ( ruleFeatureCallID ) )
+ {
+ // InternalOXtype.g:16900:2: ( ( ruleFeatureCallID ) )
+ // InternalOXtype.g:16901:3: ( ruleFeatureCallID )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0());
+ }
+ // InternalOXtype.g:16902:3: ( ruleFeatureCallID )
+ // InternalOXtype.g:16903:4: ruleFeatureCallID
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleFeatureCallID();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__ValueAssignment_1_0_1"
+ // InternalOXtype.g:16914:1: rule__XMemberFeatureCall__ValueAssignment_1_0_1 : ( ruleXAssignment ) ;
+ public final void rule__XMemberFeatureCall__ValueAssignment_1_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16918:1: ( ( ruleXAssignment ) )
+ // InternalOXtype.g:16919:2: ( ruleXAssignment )
+ {
+ // InternalOXtype.g:16919:2: ( ruleXAssignment )
+ // InternalOXtype.g:16920:3: ruleXAssignment
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXAssignment();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__ValueAssignment_1_0_1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1"
+ // InternalOXtype.g:16929:1: rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 : ( ( '?.' ) ) ;
+ public final void rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16933:1: ( ( ( '?.' ) ) )
+ // InternalOXtype.g:16934:2: ( ( '?.' ) )
+ {
+ // InternalOXtype.g:16934:2: ( ( '?.' ) )
+ // InternalOXtype.g:16935:3: ( '?.' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0());
+ }
+ // InternalOXtype.g:16936:3: ( '?.' )
+ // InternalOXtype.g:16937:4: '?.'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0());
+ }
+ match(input,85,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2"
+ // InternalOXtype.g:16948:1: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 : ( ( '::' ) ) ;
+ public final void rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16952:1: ( ( ( '::' ) ) )
+ // InternalOXtype.g:16953:2: ( ( '::' ) )
+ {
+ // InternalOXtype.g:16953:2: ( ( '::' ) )
+ // InternalOXtype.g:16954:3: ( '::' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0());
+ }
+ // InternalOXtype.g:16955:3: ( '::' )
+ // InternalOXtype.g:16956:4: '::'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0());
+ }
+ match(input,84,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1"
+ // InternalOXtype.g:16967:1: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 : ( ruleJvmArgumentTypeReference ) ;
+ public final void rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16971:1: ( ( ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:16972:2: ( ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:16972:2: ( ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:16973:3: ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1"
+ // InternalOXtype.g:16982:1: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 : ( ruleJvmArgumentTypeReference ) ;
+ public final void rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:16986:1: ( ( ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:16987:2: ( ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:16987:2: ( ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:16988:3: ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__FeatureAssignment_1_1_2"
+ // InternalOXtype.g:16997:1: rule__XMemberFeatureCall__FeatureAssignment_1_1_2 : ( ( ruleIdOrSuper ) ) ;
+ public final void rule__XMemberFeatureCall__FeatureAssignment_1_1_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17001:1: ( ( ( ruleIdOrSuper ) ) )
+ // InternalOXtype.g:17002:2: ( ( ruleIdOrSuper ) )
+ {
+ // InternalOXtype.g:17002:2: ( ( ruleIdOrSuper ) )
+ // InternalOXtype.g:17003:3: ( ruleIdOrSuper )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0());
+ }
+ // InternalOXtype.g:17004:3: ( ruleIdOrSuper )
+ // InternalOXtype.g:17005:4: ruleIdOrSuper
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleIdOrSuper();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__FeatureAssignment_1_1_2"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0"
+ // InternalOXtype.g:17016:1: rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 : ( ( '(' ) ) ;
+ public final void rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17020:1: ( ( ( '(' ) ) )
+ // InternalOXtype.g:17021:2: ( ( '(' ) )
+ {
+ // InternalOXtype.g:17021:2: ( ( '(' ) )
+ // InternalOXtype.g:17022:3: ( '(' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0());
+ }
+ // InternalOXtype.g:17023:3: ( '(' )
+ // InternalOXtype.g:17024:4: '('
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0());
+ }
+ match(input,53,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0"
+ // InternalOXtype.g:17035:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 : ( ruleXShortClosure ) ;
+ public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17039:1: ( ( ruleXShortClosure ) )
+ // InternalOXtype.g:17040:2: ( ruleXShortClosure )
+ {
+ // InternalOXtype.g:17040:2: ( ruleXShortClosure )
+ // InternalOXtype.g:17041:3: ruleXShortClosure
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXShortClosure();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0"
+ // InternalOXtype.g:17050:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 : ( ruleXExpression ) ;
+ public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17054:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17055:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17055:2: ( ruleXExpression )
+ // InternalOXtype.g:17056:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1"
+ // InternalOXtype.g:17065:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 : ( ruleXExpression ) ;
+ public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17069:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17070:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17070:2: ( ruleXExpression )
+ // InternalOXtype.g:17071:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1"
+
+
+ // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4"
+ // InternalOXtype.g:17080:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 : ( ruleXClosure ) ;
+ public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17084:1: ( ( ruleXClosure ) )
+ // InternalOXtype.g:17085:2: ( ruleXClosure )
+ {
+ // InternalOXtype.g:17085:2: ( ruleXClosure )
+ // InternalOXtype.g:17086:3: ruleXClosure
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXClosure();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4"
+
+
+ // $ANTLR start "rule__XSetLiteral__ElementsAssignment_3_0"
+ // InternalOXtype.g:17095:1: rule__XSetLiteral__ElementsAssignment_3_0 : ( ruleXExpression ) ;
+ public final void rule__XSetLiteral__ElementsAssignment_3_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17099:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17100:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17100:2: ( ruleXExpression )
+ // InternalOXtype.g:17101:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__ElementsAssignment_3_0"
+
+
+ // $ANTLR start "rule__XSetLiteral__ElementsAssignment_3_1_1"
+ // InternalOXtype.g:17110:1: rule__XSetLiteral__ElementsAssignment_3_1_1 : ( ruleXExpression ) ;
+ public final void rule__XSetLiteral__ElementsAssignment_3_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17114:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17115:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17115:2: ( ruleXExpression )
+ // InternalOXtype.g:17116:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSetLiteral__ElementsAssignment_3_1_1"
+
+
+ // $ANTLR start "rule__XListLiteral__ElementsAssignment_3_0"
+ // InternalOXtype.g:17125:1: rule__XListLiteral__ElementsAssignment_3_0 : ( ruleXExpression ) ;
+ public final void rule__XListLiteral__ElementsAssignment_3_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17129:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17130:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17130:2: ( ruleXExpression )
+ // InternalOXtype.g:17131:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__ElementsAssignment_3_0"
+
+
+ // $ANTLR start "rule__XListLiteral__ElementsAssignment_3_1_1"
+ // InternalOXtype.g:17140:1: rule__XListLiteral__ElementsAssignment_3_1_1 : ( ruleXExpression ) ;
+ public final void rule__XListLiteral__ElementsAssignment_3_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17144:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17145:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17145:2: ( ruleXExpression )
+ // InternalOXtype.g:17146:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XListLiteral__ElementsAssignment_3_1_1"
+
+
+ // $ANTLR start "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0"
+ // InternalOXtype.g:17155:1: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 : ( ruleJvmFormalParameter ) ;
+ public final void rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17159:1: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:17160:2: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:17160:2: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:17161:3: ruleJvmFormalParameter
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0"
+
+
+ // $ANTLR start "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1"
+ // InternalOXtype.g:17170:1: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 : ( ruleJvmFormalParameter ) ;
+ public final void rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17174:1: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:17175:2: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:17175:2: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:17176:3: ruleJvmFormalParameter
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1"
+
+
+ // $ANTLR start "rule__XClosure__ExplicitSyntaxAssignment_1_0_1"
+ // InternalOXtype.g:17185:1: rule__XClosure__ExplicitSyntaxAssignment_1_0_1 : ( ( '|' ) ) ;
+ public final void rule__XClosure__ExplicitSyntaxAssignment_1_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17189:1: ( ( ( '|' ) ) )
+ // InternalOXtype.g:17190:2: ( ( '|' ) )
+ {
+ // InternalOXtype.g:17190:2: ( ( '|' ) )
+ // InternalOXtype.g:17191:3: ( '|' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0());
+ }
+ // InternalOXtype.g:17192:3: ( '|' )
+ // InternalOXtype.g:17193:4: '|'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0());
+ }
+ match(input,86,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__ExplicitSyntaxAssignment_1_0_1"
+
+
+ // $ANTLR start "rule__XClosure__ExpressionAssignment_2"
+ // InternalOXtype.g:17204:1: rule__XClosure__ExpressionAssignment_2 : ( ruleXExpressionInClosure ) ;
+ public final void rule__XClosure__ExpressionAssignment_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17208:1: ( ( ruleXExpressionInClosure ) )
+ // InternalOXtype.g:17209:2: ( ruleXExpressionInClosure )
+ {
+ // InternalOXtype.g:17209:2: ( ruleXExpressionInClosure )
+ // InternalOXtype.g:17210:3: ruleXExpressionInClosure
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpressionInClosure();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XClosure__ExpressionAssignment_2"
+
+
+ // $ANTLR start "rule__XExpressionInClosure__ExpressionsAssignment_1_0"
+ // InternalOXtype.g:17219:1: rule__XExpressionInClosure__ExpressionsAssignment_1_0 : ( ruleXExpressionOrVarDeclaration ) ;
+ public final void rule__XExpressionInClosure__ExpressionsAssignment_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17223:1: ( ( ruleXExpressionOrVarDeclaration ) )
+ // InternalOXtype.g:17224:2: ( ruleXExpressionOrVarDeclaration )
+ {
+ // InternalOXtype.g:17224:2: ( ruleXExpressionOrVarDeclaration )
+ // InternalOXtype.g:17225:3: ruleXExpressionOrVarDeclaration
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpressionOrVarDeclaration();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XExpressionInClosure__ExpressionsAssignment_1_0"
+
+
+ // $ANTLR start "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0"
+ // InternalOXtype.g:17234:1: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 : ( ruleJvmFormalParameter ) ;
+ public final void rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17238:1: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:17239:2: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:17239:2: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:17240:3: ruleJvmFormalParameter
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0"
+
+
+ // $ANTLR start "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1"
+ // InternalOXtype.g:17249:1: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 : ( ruleJvmFormalParameter ) ;
+ public final void rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17253:1: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:17254:2: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:17254:2: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:17255:3: ruleJvmFormalParameter
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1"
+
+
+ // $ANTLR start "rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2"
+ // InternalOXtype.g:17264:1: rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 : ( ( '|' ) ) ;
+ public final void rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17268:1: ( ( ( '|' ) ) )
+ // InternalOXtype.g:17269:2: ( ( '|' ) )
+ {
+ // InternalOXtype.g:17269:2: ( ( '|' ) )
+ // InternalOXtype.g:17270:3: ( '|' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0());
+ }
+ // InternalOXtype.g:17271:3: ( '|' )
+ // InternalOXtype.g:17272:4: '|'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0());
+ }
+ match(input,86,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2"
+
+
+ // $ANTLR start "rule__XShortClosure__ExpressionAssignment_1"
+ // InternalOXtype.g:17283:1: rule__XShortClosure__ExpressionAssignment_1 : ( ruleXExpression ) ;
+ public final void rule__XShortClosure__ExpressionAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17287:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17288:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17288:2: ( ruleXExpression )
+ // InternalOXtype.g:17289:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XShortClosure__ExpressionAssignment_1"
+
+
+ // $ANTLR start "rule__XIfExpression__IfAssignment_3"
+ // InternalOXtype.g:17298:1: rule__XIfExpression__IfAssignment_3 : ( ruleXExpression ) ;
+ public final void rule__XIfExpression__IfAssignment_3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17302:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17303:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17303:2: ( ruleXExpression )
+ // InternalOXtype.g:17304:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__IfAssignment_3"
+
+
+ // $ANTLR start "rule__XIfExpression__ThenAssignment_5"
+ // InternalOXtype.g:17313:1: rule__XIfExpression__ThenAssignment_5 : ( ruleXExpression ) ;
+ public final void rule__XIfExpression__ThenAssignment_5() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17317:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17318:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17318:2: ( ruleXExpression )
+ // InternalOXtype.g:17319:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__ThenAssignment_5"
+
+
+ // $ANTLR start "rule__XIfExpression__ElseAssignment_6_1"
+ // InternalOXtype.g:17328:1: rule__XIfExpression__ElseAssignment_6_1 : ( ruleXExpression ) ;
+ public final void rule__XIfExpression__ElseAssignment_6_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17332:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17333:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17333:2: ( ruleXExpression )
+ // InternalOXtype.g:17334:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XIfExpression__ElseAssignment_6_1"
+
+
+ // $ANTLR start "rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1"
+ // InternalOXtype.g:17343:1: rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 : ( ruleJvmFormalParameter ) ;
+ public final void rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17347:1: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:17348:2: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:17348:2: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:17349:3: ruleJvmFormalParameter
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1"
+
+
+ // $ANTLR start "rule__XSwitchExpression__SwitchAssignment_2_0_1"
+ // InternalOXtype.g:17358:1: rule__XSwitchExpression__SwitchAssignment_2_0_1 : ( ruleXExpression ) ;
+ public final void rule__XSwitchExpression__SwitchAssignment_2_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17362:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17363:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17363:2: ( ruleXExpression )
+ // InternalOXtype.g:17364:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__SwitchAssignment_2_0_1"
+
+
+ // $ANTLR start "rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0"
+ // InternalOXtype.g:17373:1: rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 : ( ruleJvmFormalParameter ) ;
+ public final void rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17377:1: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:17378:2: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:17378:2: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:17379:3: ruleJvmFormalParameter
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0"
+
+
+ // $ANTLR start "rule__XSwitchExpression__SwitchAssignment_2_1_1"
+ // InternalOXtype.g:17388:1: rule__XSwitchExpression__SwitchAssignment_2_1_1 : ( ruleXExpression ) ;
+ public final void rule__XSwitchExpression__SwitchAssignment_2_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17392:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17393:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17393:2: ( ruleXExpression )
+ // InternalOXtype.g:17394:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__SwitchAssignment_2_1_1"
+
+
+ // $ANTLR start "rule__XSwitchExpression__CasesAssignment_4"
+ // InternalOXtype.g:17403:1: rule__XSwitchExpression__CasesAssignment_4 : ( ruleXCasePart ) ;
+ public final void rule__XSwitchExpression__CasesAssignment_4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17407:1: ( ( ruleXCasePart ) )
+ // InternalOXtype.g:17408:2: ( ruleXCasePart )
+ {
+ // InternalOXtype.g:17408:2: ( ruleXCasePart )
+ // InternalOXtype.g:17409:3: ruleXCasePart
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXCasePart();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__CasesAssignment_4"
+
+
+ // $ANTLR start "rule__XSwitchExpression__DefaultAssignment_5_2"
+ // InternalOXtype.g:17418:1: rule__XSwitchExpression__DefaultAssignment_5_2 : ( ruleXExpression ) ;
+ public final void rule__XSwitchExpression__DefaultAssignment_5_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17422:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17423:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17423:2: ( ruleXExpression )
+ // InternalOXtype.g:17424:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSwitchExpression__DefaultAssignment_5_2"
+
+
+ // $ANTLR start "rule__XCasePart__TypeGuardAssignment_1"
+ // InternalOXtype.g:17433:1: rule__XCasePart__TypeGuardAssignment_1 : ( ruleJvmTypeReference ) ;
+ public final void rule__XCasePart__TypeGuardAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17437:1: ( ( ruleJvmTypeReference ) )
+ // InternalOXtype.g:17438:2: ( ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:17438:2: ( ruleJvmTypeReference )
+ // InternalOXtype.g:17439:3: ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__TypeGuardAssignment_1"
+
+
+ // $ANTLR start "rule__XCasePart__CaseAssignment_2_1"
+ // InternalOXtype.g:17448:1: rule__XCasePart__CaseAssignment_2_1 : ( ruleXExpression ) ;
+ public final void rule__XCasePart__CaseAssignment_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17452:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17453:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17453:2: ( ruleXExpression )
+ // InternalOXtype.g:17454:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__CaseAssignment_2_1"
+
+
+ // $ANTLR start "rule__XCasePart__ThenAssignment_3_0_1"
+ // InternalOXtype.g:17463:1: rule__XCasePart__ThenAssignment_3_0_1 : ( ruleXExpression ) ;
+ public final void rule__XCasePart__ThenAssignment_3_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17467:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17468:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17468:2: ( ruleXExpression )
+ // InternalOXtype.g:17469:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__ThenAssignment_3_0_1"
+
+
+ // $ANTLR start "rule__XCasePart__FallThroughAssignment_3_1"
+ // InternalOXtype.g:17478:1: rule__XCasePart__FallThroughAssignment_3_1 : ( ( ',' ) ) ;
+ public final void rule__XCasePart__FallThroughAssignment_3_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17482:1: ( ( ( ',' ) ) )
+ // InternalOXtype.g:17483:2: ( ( ',' ) )
+ {
+ // InternalOXtype.g:17483:2: ( ( ',' ) )
+ // InternalOXtype.g:17484:3: ( ',' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0());
+ }
+ // InternalOXtype.g:17485:3: ( ',' )
+ // InternalOXtype.g:17486:4: ','
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0());
+ }
+ match(input,55,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCasePart__FallThroughAssignment_3_1"
+
+
+ // $ANTLR start "rule__XForLoopExpression__DeclaredParamAssignment_0_0_3"
+ // InternalOXtype.g:17497:1: rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 : ( ruleJvmFormalParameter ) ;
+ public final void rule__XForLoopExpression__DeclaredParamAssignment_0_0_3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17501:1: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:17502:2: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:17502:2: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:17503:3: ruleJvmFormalParameter
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__DeclaredParamAssignment_0_0_3"
+
+
+ // $ANTLR start "rule__XForLoopExpression__ForExpressionAssignment_1"
+ // InternalOXtype.g:17512:1: rule__XForLoopExpression__ForExpressionAssignment_1 : ( ruleXExpression ) ;
+ public final void rule__XForLoopExpression__ForExpressionAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17516:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17517:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17517:2: ( ruleXExpression )
+ // InternalOXtype.g:17518:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__ForExpressionAssignment_1"
+
+
+ // $ANTLR start "rule__XForLoopExpression__EachExpressionAssignment_3"
+ // InternalOXtype.g:17527:1: rule__XForLoopExpression__EachExpressionAssignment_3 : ( ruleXExpression ) ;
+ public final void rule__XForLoopExpression__EachExpressionAssignment_3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17531:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17532:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17532:2: ( ruleXExpression )
+ // InternalOXtype.g:17533:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XForLoopExpression__EachExpressionAssignment_3"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0"
+ // InternalOXtype.g:17542:1: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 : ( ruleXExpressionOrVarDeclaration ) ;
+ public final void rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17546:1: ( ( ruleXExpressionOrVarDeclaration ) )
+ // InternalOXtype.g:17547:2: ( ruleXExpressionOrVarDeclaration )
+ {
+ // InternalOXtype.g:17547:2: ( ruleXExpressionOrVarDeclaration )
+ // InternalOXtype.g:17548:3: ruleXExpressionOrVarDeclaration
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpressionOrVarDeclaration();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1"
+ // InternalOXtype.g:17557:1: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 : ( ruleXExpressionOrVarDeclaration ) ;
+ public final void rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17561:1: ( ( ruleXExpressionOrVarDeclaration ) )
+ // InternalOXtype.g:17562:2: ( ruleXExpressionOrVarDeclaration )
+ {
+ // InternalOXtype.g:17562:2: ( ruleXExpressionOrVarDeclaration )
+ // InternalOXtype.g:17563:3: ruleXExpressionOrVarDeclaration
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpressionOrVarDeclaration();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__ExpressionAssignment_5"
+ // InternalOXtype.g:17572:1: rule__XBasicForLoopExpression__ExpressionAssignment_5 : ( ruleXExpression ) ;
+ public final void rule__XBasicForLoopExpression__ExpressionAssignment_5() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17576:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17577:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17577:2: ( ruleXExpression )
+ // InternalOXtype.g:17578:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__ExpressionAssignment_5"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0"
+ // InternalOXtype.g:17587:1: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 : ( ruleXExpression ) ;
+ public final void rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17591:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17592:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17592:2: ( ruleXExpression )
+ // InternalOXtype.g:17593:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1"
+ // InternalOXtype.g:17602:1: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 : ( ruleXExpression ) ;
+ public final void rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17606:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17607:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17607:2: ( ruleXExpression )
+ // InternalOXtype.g:17608:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1"
+
+
+ // $ANTLR start "rule__XBasicForLoopExpression__EachExpressionAssignment_9"
+ // InternalOXtype.g:17617:1: rule__XBasicForLoopExpression__EachExpressionAssignment_9 : ( ruleXExpression ) ;
+ public final void rule__XBasicForLoopExpression__EachExpressionAssignment_9() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17621:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17622:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17622:2: ( ruleXExpression )
+ // InternalOXtype.g:17623:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBasicForLoopExpression__EachExpressionAssignment_9"
+
+
+ // $ANTLR start "rule__XWhileExpression__PredicateAssignment_3"
+ // InternalOXtype.g:17632:1: rule__XWhileExpression__PredicateAssignment_3 : ( ruleXExpression ) ;
+ public final void rule__XWhileExpression__PredicateAssignment_3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17636:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17637:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17637:2: ( ruleXExpression )
+ // InternalOXtype.g:17638:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XWhileExpression__PredicateAssignment_3"
+
+
+ // $ANTLR start "rule__XWhileExpression__BodyAssignment_5"
+ // InternalOXtype.g:17647:1: rule__XWhileExpression__BodyAssignment_5 : ( ruleXExpression ) ;
+ public final void rule__XWhileExpression__BodyAssignment_5() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17651:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17652:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17652:2: ( ruleXExpression )
+ // InternalOXtype.g:17653:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XWhileExpression__BodyAssignment_5"
+
+
+ // $ANTLR start "rule__XDoWhileExpression__BodyAssignment_2"
+ // InternalOXtype.g:17662:1: rule__XDoWhileExpression__BodyAssignment_2 : ( ruleXExpression ) ;
+ public final void rule__XDoWhileExpression__BodyAssignment_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17666:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17667:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17667:2: ( ruleXExpression )
+ // InternalOXtype.g:17668:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XDoWhileExpression__BodyAssignment_2"
+
+
+ // $ANTLR start "rule__XDoWhileExpression__PredicateAssignment_5"
+ // InternalOXtype.g:17677:1: rule__XDoWhileExpression__PredicateAssignment_5 : ( ruleXExpression ) ;
+ public final void rule__XDoWhileExpression__PredicateAssignment_5() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17681:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17682:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17682:2: ( ruleXExpression )
+ // InternalOXtype.g:17683:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XDoWhileExpression__PredicateAssignment_5"
+
+
+ // $ANTLR start "rule__XBlockExpression__ExpressionsAssignment_2_0"
+ // InternalOXtype.g:17692:1: rule__XBlockExpression__ExpressionsAssignment_2_0 : ( ruleXExpressionOrVarDeclaration ) ;
+ public final void rule__XBlockExpression__ExpressionsAssignment_2_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17696:1: ( ( ruleXExpressionOrVarDeclaration ) )
+ // InternalOXtype.g:17697:2: ( ruleXExpressionOrVarDeclaration )
+ {
+ // InternalOXtype.g:17697:2: ( ruleXExpressionOrVarDeclaration )
+ // InternalOXtype.g:17698:3: ruleXExpressionOrVarDeclaration
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpressionOrVarDeclaration();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBlockExpression__ExpressionsAssignment_2_0"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__WriteableAssignment_1_0"
+ // InternalOXtype.g:17707:1: rule__XVariableDeclaration__WriteableAssignment_1_0 : ( ( 'var' ) ) ;
+ public final void rule__XVariableDeclaration__WriteableAssignment_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17711:1: ( ( ( 'var' ) ) )
+ // InternalOXtype.g:17712:2: ( ( 'var' ) )
+ {
+ // InternalOXtype.g:17712:2: ( ( 'var' ) )
+ // InternalOXtype.g:17713:3: ( 'var' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0());
+ }
+ // InternalOXtype.g:17714:3: ( 'var' )
+ // InternalOXtype.g:17715:4: 'var'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0());
+ }
+ match(input,87,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__WriteableAssignment_1_0"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__TypeAssignment_2_0_0_0"
+ // InternalOXtype.g:17726:1: rule__XVariableDeclaration__TypeAssignment_2_0_0_0 : ( ruleJvmTypeReference ) ;
+ public final void rule__XVariableDeclaration__TypeAssignment_2_0_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17730:1: ( ( ruleJvmTypeReference ) )
+ // InternalOXtype.g:17731:2: ( ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:17731:2: ( ruleJvmTypeReference )
+ // InternalOXtype.g:17732:3: ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__TypeAssignment_2_0_0_0"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__NameAssignment_2_0_0_1"
+ // InternalOXtype.g:17741:1: rule__XVariableDeclaration__NameAssignment_2_0_0_1 : ( ruleValidID ) ;
+ public final void rule__XVariableDeclaration__NameAssignment_2_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17745:1: ( ( ruleValidID ) )
+ // InternalOXtype.g:17746:2: ( ruleValidID )
+ {
+ // InternalOXtype.g:17746:2: ( ruleValidID )
+ // InternalOXtype.g:17747:3: ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__NameAssignment_2_0_0_1"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__NameAssignment_2_1"
+ // InternalOXtype.g:17756:1: rule__XVariableDeclaration__NameAssignment_2_1 : ( ruleValidID ) ;
+ public final void rule__XVariableDeclaration__NameAssignment_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17760:1: ( ( ruleValidID ) )
+ // InternalOXtype.g:17761:2: ( ruleValidID )
+ {
+ // InternalOXtype.g:17761:2: ( ruleValidID )
+ // InternalOXtype.g:17762:3: ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__NameAssignment_2_1"
+
+
+ // $ANTLR start "rule__XVariableDeclaration__RightAssignment_3_1"
+ // InternalOXtype.g:17771:1: rule__XVariableDeclaration__RightAssignment_3_1 : ( ruleXExpression ) ;
+ public final void rule__XVariableDeclaration__RightAssignment_3_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17775:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17776:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17776:2: ( ruleXExpression )
+ // InternalOXtype.g:17777:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XVariableDeclaration__RightAssignment_3_1"
+
+
+ // $ANTLR start "rule__JvmFormalParameter__ParameterTypeAssignment_0"
+ // InternalOXtype.g:17786:1: rule__JvmFormalParameter__ParameterTypeAssignment_0 : ( ruleJvmTypeReference ) ;
+ public final void rule__JvmFormalParameter__ParameterTypeAssignment_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17790:1: ( ( ruleJvmTypeReference ) )
+ // InternalOXtype.g:17791:2: ( ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:17791:2: ( ruleJvmTypeReference )
+ // InternalOXtype.g:17792:3: ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmFormalParameter__ParameterTypeAssignment_0"
+
+
+ // $ANTLR start "rule__JvmFormalParameter__NameAssignment_1"
+ // InternalOXtype.g:17801:1: rule__JvmFormalParameter__NameAssignment_1 : ( ruleValidID ) ;
+ public final void rule__JvmFormalParameter__NameAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17805:1: ( ( ruleValidID ) )
+ // InternalOXtype.g:17806:2: ( ruleValidID )
+ {
+ // InternalOXtype.g:17806:2: ( ruleValidID )
+ // InternalOXtype.g:17807:3: ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmFormalParameter__NameAssignment_1"
+
+
+ // $ANTLR start "rule__FullJvmFormalParameter__ParameterTypeAssignment_0"
+ // InternalOXtype.g:17816:1: rule__FullJvmFormalParameter__ParameterTypeAssignment_0 : ( ruleJvmTypeReference ) ;
+ public final void rule__FullJvmFormalParameter__ParameterTypeAssignment_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17820:1: ( ( ruleJvmTypeReference ) )
+ // InternalOXtype.g:17821:2: ( ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:17821:2: ( ruleJvmTypeReference )
+ // InternalOXtype.g:17822:3: ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FullJvmFormalParameter__ParameterTypeAssignment_0"
+
+
+ // $ANTLR start "rule__FullJvmFormalParameter__NameAssignment_1"
+ // InternalOXtype.g:17831:1: rule__FullJvmFormalParameter__NameAssignment_1 : ( ruleValidID ) ;
+ public final void rule__FullJvmFormalParameter__NameAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17835:1: ( ( ruleValidID ) )
+ // InternalOXtype.g:17836:2: ( ruleValidID )
+ {
+ // InternalOXtype.g:17836:2: ( ruleValidID )
+ // InternalOXtype.g:17837:3: ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FullJvmFormalParameter__NameAssignment_1"
+
+
+ // $ANTLR start "rule__XFeatureCall__TypeArgumentsAssignment_1_1"
+ // InternalOXtype.g:17846:1: rule__XFeatureCall__TypeArgumentsAssignment_1_1 : ( ruleJvmArgumentTypeReference ) ;
+ public final void rule__XFeatureCall__TypeArgumentsAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17850:1: ( ( ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:17851:2: ( ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:17851:2: ( ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:17852:3: ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__TypeArgumentsAssignment_1_1"
+
+
+ // $ANTLR start "rule__XFeatureCall__TypeArgumentsAssignment_1_2_1"
+ // InternalOXtype.g:17861:1: rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 : ( ruleJvmArgumentTypeReference ) ;
+ public final void rule__XFeatureCall__TypeArgumentsAssignment_1_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17865:1: ( ( ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:17866:2: ( ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:17866:2: ( ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:17867:3: ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__TypeArgumentsAssignment_1_2_1"
+
+
+ // $ANTLR start "rule__XFeatureCall__FeatureAssignment_2"
+ // InternalOXtype.g:17876:1: rule__XFeatureCall__FeatureAssignment_2 : ( ( ruleIdOrSuper ) ) ;
+ public final void rule__XFeatureCall__FeatureAssignment_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17880:1: ( ( ( ruleIdOrSuper ) ) )
+ // InternalOXtype.g:17881:2: ( ( ruleIdOrSuper ) )
+ {
+ // InternalOXtype.g:17881:2: ( ( ruleIdOrSuper ) )
+ // InternalOXtype.g:17882:3: ( ruleIdOrSuper )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0());
+ }
+ // InternalOXtype.g:17883:3: ( ruleIdOrSuper )
+ // InternalOXtype.g:17884:4: ruleIdOrSuper
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleIdOrSuper();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__FeatureAssignment_2"
+
+
+ // $ANTLR start "rule__XFeatureCall__ExplicitOperationCallAssignment_3_0"
+ // InternalOXtype.g:17895:1: rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 : ( ( '(' ) ) ;
+ public final void rule__XFeatureCall__ExplicitOperationCallAssignment_3_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17899:1: ( ( ( '(' ) ) )
+ // InternalOXtype.g:17900:2: ( ( '(' ) )
+ {
+ // InternalOXtype.g:17900:2: ( ( '(' ) )
+ // InternalOXtype.g:17901:3: ( '(' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0());
+ }
+ // InternalOXtype.g:17902:3: ( '(' )
+ // InternalOXtype.g:17903:4: '('
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0());
+ }
+ match(input,53,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__ExplicitOperationCallAssignment_3_0"
+
+
+ // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0"
+ // InternalOXtype.g:17914:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 : ( ruleXShortClosure ) ;
+ public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17918:1: ( ( ruleXShortClosure ) )
+ // InternalOXtype.g:17919:2: ( ruleXShortClosure )
+ {
+ // InternalOXtype.g:17919:2: ( ruleXShortClosure )
+ // InternalOXtype.g:17920:3: ruleXShortClosure
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXShortClosure();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0"
+
+
+ // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0"
+ // InternalOXtype.g:17929:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 : ( ruleXExpression ) ;
+ public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17933:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17934:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17934:2: ( ruleXExpression )
+ // InternalOXtype.g:17935:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0"
+
+
+ // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1"
+ // InternalOXtype.g:17944:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 : ( ruleXExpression ) ;
+ public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17948:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:17949:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:17949:2: ( ruleXExpression )
+ // InternalOXtype.g:17950:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1"
+
+
+ // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_4"
+ // InternalOXtype.g:17959:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_4 : ( ruleXClosure ) ;
+ public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17963:1: ( ( ruleXClosure ) )
+ // InternalOXtype.g:17964:2: ( ruleXClosure )
+ {
+ // InternalOXtype.g:17964:2: ( ruleXClosure )
+ // InternalOXtype.g:17965:3: ruleXClosure
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXClosure();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_4"
+
+
+ // $ANTLR start "rule__XConstructorCall__ConstructorAssignment_2"
+ // InternalOXtype.g:17974:1: rule__XConstructorCall__ConstructorAssignment_2 : ( ( ruleQualifiedName ) ) ;
+ public final void rule__XConstructorCall__ConstructorAssignment_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17978:1: ( ( ( ruleQualifiedName ) ) )
+ // InternalOXtype.g:17979:2: ( ( ruleQualifiedName ) )
+ {
+ // InternalOXtype.g:17979:2: ( ( ruleQualifiedName ) )
+ // InternalOXtype.g:17980:3: ( ruleQualifiedName )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0());
+ }
+ // InternalOXtype.g:17981:3: ( ruleQualifiedName )
+ // InternalOXtype.g:17982:4: ruleQualifiedName
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleQualifiedName();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__ConstructorAssignment_2"
+
+
+ // $ANTLR start "rule__XConstructorCall__TypeArgumentsAssignment_3_1"
+ // InternalOXtype.g:17993:1: rule__XConstructorCall__TypeArgumentsAssignment_3_1 : ( ruleJvmArgumentTypeReference ) ;
+ public final void rule__XConstructorCall__TypeArgumentsAssignment_3_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:17997:1: ( ( ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:17998:2: ( ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:17998:2: ( ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:17999:3: ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__TypeArgumentsAssignment_3_1"
+
+
+ // $ANTLR start "rule__XConstructorCall__TypeArgumentsAssignment_3_2_1"
+ // InternalOXtype.g:18008:1: rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 : ( ruleJvmArgumentTypeReference ) ;
+ public final void rule__XConstructorCall__TypeArgumentsAssignment_3_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18012:1: ( ( ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:18013:2: ( ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:18013:2: ( ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:18014:3: ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__TypeArgumentsAssignment_3_2_1"
+
+
+ // $ANTLR start "rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0"
+ // InternalOXtype.g:18023:1: rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 : ( ( '(' ) ) ;
+ public final void rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18027:1: ( ( ( '(' ) ) )
+ // InternalOXtype.g:18028:2: ( ( '(' ) )
+ {
+ // InternalOXtype.g:18028:2: ( ( '(' ) )
+ // InternalOXtype.g:18029:3: ( '(' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0());
+ }
+ // InternalOXtype.g:18030:3: ( '(' )
+ // InternalOXtype.g:18031:4: '('
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0());
+ }
+ match(input,53,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0"
+
+
+ // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_4_1_0"
+ // InternalOXtype.g:18042:1: rule__XConstructorCall__ArgumentsAssignment_4_1_0 : ( ruleXShortClosure ) ;
+ public final void rule__XConstructorCall__ArgumentsAssignment_4_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18046:1: ( ( ruleXShortClosure ) )
+ // InternalOXtype.g:18047:2: ( ruleXShortClosure )
+ {
+ // InternalOXtype.g:18047:2: ( ruleXShortClosure )
+ // InternalOXtype.g:18048:3: ruleXShortClosure
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXShortClosure();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_4_1_0"
+
+
+ // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_4_1_1_0"
+ // InternalOXtype.g:18057:1: rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 : ( ruleXExpression ) ;
+ public final void rule__XConstructorCall__ArgumentsAssignment_4_1_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18061:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:18062:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:18062:2: ( ruleXExpression )
+ // InternalOXtype.g:18063:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_4_1_1_0"
+
+
+ // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1"
+ // InternalOXtype.g:18072:1: rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 : ( ruleXExpression ) ;
+ public final void rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18076:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:18077:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:18077:2: ( ruleXExpression )
+ // InternalOXtype.g:18078:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1"
+
+
+ // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_5"
+ // InternalOXtype.g:18087:1: rule__XConstructorCall__ArgumentsAssignment_5 : ( ruleXClosure ) ;
+ public final void rule__XConstructorCall__ArgumentsAssignment_5() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18091:1: ( ( ruleXClosure ) )
+ // InternalOXtype.g:18092:2: ( ruleXClosure )
+ {
+ // InternalOXtype.g:18092:2: ( ruleXClosure )
+ // InternalOXtype.g:18093:3: ruleXClosure
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXClosure();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_5"
+
+
+ // $ANTLR start "rule__XBooleanLiteral__IsTrueAssignment_1_1"
+ // InternalOXtype.g:18102:1: rule__XBooleanLiteral__IsTrueAssignment_1_1 : ( ( 'true' ) ) ;
+ public final void rule__XBooleanLiteral__IsTrueAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18106:1: ( ( ( 'true' ) ) )
+ // InternalOXtype.g:18107:2: ( ( 'true' ) )
+ {
+ // InternalOXtype.g:18107:2: ( ( 'true' ) )
+ // InternalOXtype.g:18108:3: ( 'true' )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0());
+ }
+ // InternalOXtype.g:18109:3: ( 'true' )
+ // InternalOXtype.g:18110:4: 'true'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0());
+ }
+ match(input,88,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XBooleanLiteral__IsTrueAssignment_1_1"
+
+
+ // $ANTLR start "rule__XNumberLiteral__ValueAssignment_1"
+ // InternalOXtype.g:18121:1: rule__XNumberLiteral__ValueAssignment_1 : ( ruleNumber ) ;
+ public final void rule__XNumberLiteral__ValueAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18125:1: ( ( ruleNumber ) )
+ // InternalOXtype.g:18126:2: ( ruleNumber )
+ {
+ // InternalOXtype.g:18126:2: ( ruleNumber )
+ // InternalOXtype.g:18127:3: ruleNumber
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleNumber();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XNumberLiteral__ValueAssignment_1"
+
+
+ // $ANTLR start "rule__XStringLiteral__ValueAssignment_1"
+ // InternalOXtype.g:18136:1: rule__XStringLiteral__ValueAssignment_1 : ( RULE_STRING ) ;
+ public final void rule__XStringLiteral__ValueAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18140:1: ( ( RULE_STRING ) )
+ // InternalOXtype.g:18141:2: ( RULE_STRING )
+ {
+ // InternalOXtype.g:18141:2: ( RULE_STRING )
+ // InternalOXtype.g:18142:3: RULE_STRING
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0());
+ }
+ match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XStringLiteral__ValueAssignment_1"
+
+
+ // $ANTLR start "rule__XTypeLiteral__TypeAssignment_3"
+ // InternalOXtype.g:18151:1: rule__XTypeLiteral__TypeAssignment_3 : ( ( ruleQualifiedName ) ) ;
+ public final void rule__XTypeLiteral__TypeAssignment_3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18155:1: ( ( ( ruleQualifiedName ) ) )
+ // InternalOXtype.g:18156:2: ( ( ruleQualifiedName ) )
+ {
+ // InternalOXtype.g:18156:2: ( ( ruleQualifiedName ) )
+ // InternalOXtype.g:18157:3: ( ruleQualifiedName )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0());
+ }
+ // InternalOXtype.g:18158:3: ( ruleQualifiedName )
+ // InternalOXtype.g:18159:4: ruleQualifiedName
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleQualifiedName();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTypeLiteral__TypeAssignment_3"
+
+
+ // $ANTLR start "rule__XTypeLiteral__ArrayDimensionsAssignment_4"
+ // InternalOXtype.g:18170:1: rule__XTypeLiteral__ArrayDimensionsAssignment_4 : ( ruleArrayBrackets ) ;
+ public final void rule__XTypeLiteral__ArrayDimensionsAssignment_4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18174:1: ( ( ruleArrayBrackets ) )
+ // InternalOXtype.g:18175:2: ( ruleArrayBrackets )
+ {
+ // InternalOXtype.g:18175:2: ( ruleArrayBrackets )
+ // InternalOXtype.g:18176:3: ruleArrayBrackets
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleArrayBrackets();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTypeLiteral__ArrayDimensionsAssignment_4"
+
+
+ // $ANTLR start "rule__XThrowExpression__ExpressionAssignment_2"
+ // InternalOXtype.g:18185:1: rule__XThrowExpression__ExpressionAssignment_2 : ( ruleXExpression ) ;
+ public final void rule__XThrowExpression__ExpressionAssignment_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18189:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:18190:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:18190:2: ( ruleXExpression )
+ // InternalOXtype.g:18191:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XThrowExpression__ExpressionAssignment_2"
+
+
+ // $ANTLR start "rule__XReturnExpression__ExpressionAssignment_2"
+ // InternalOXtype.g:18200:1: rule__XReturnExpression__ExpressionAssignment_2 : ( ruleXExpression ) ;
+ public final void rule__XReturnExpression__ExpressionAssignment_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18204:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:18205:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:18205:2: ( ruleXExpression )
+ // InternalOXtype.g:18206:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XReturnExpression__ExpressionAssignment_2"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__ExpressionAssignment_2"
+ // InternalOXtype.g:18215:1: rule__XTryCatchFinallyExpression__ExpressionAssignment_2 : ( ruleXExpression ) ;
+ public final void rule__XTryCatchFinallyExpression__ExpressionAssignment_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18219:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:18220:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:18220:2: ( ruleXExpression )
+ // InternalOXtype.g:18221:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__ExpressionAssignment_2"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0"
+ // InternalOXtype.g:18230:1: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 : ( ruleXCatchClause ) ;
+ public final void rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18234:1: ( ( ruleXCatchClause ) )
+ // InternalOXtype.g:18235:2: ( ruleXCatchClause )
+ {
+ // InternalOXtype.g:18235:2: ( ruleXCatchClause )
+ // InternalOXtype.g:18236:3: ruleXCatchClause
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXCatchClause();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1"
+ // InternalOXtype.g:18245:1: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 : ( ruleXExpression ) ;
+ public final void rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18249:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:18250:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:18250:2: ( ruleXExpression )
+ // InternalOXtype.g:18251:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1"
+
+
+ // $ANTLR start "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1"
+ // InternalOXtype.g:18260:1: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 : ( ruleXExpression ) ;
+ public final void rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18264:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:18265:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:18265:2: ( ruleXExpression )
+ // InternalOXtype.g:18266:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__ParamAssignment_1"
+ // InternalOXtype.g:18275:1: rule__XSynchronizedExpression__ParamAssignment_1 : ( ruleXExpression ) ;
+ public final void rule__XSynchronizedExpression__ParamAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18279:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:18280:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:18280:2: ( ruleXExpression )
+ // InternalOXtype.g:18281:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__ParamAssignment_1"
+
+
+ // $ANTLR start "rule__XSynchronizedExpression__ExpressionAssignment_3"
+ // InternalOXtype.g:18290:1: rule__XSynchronizedExpression__ExpressionAssignment_3 : ( ruleXExpression ) ;
+ public final void rule__XSynchronizedExpression__ExpressionAssignment_3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18294:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:18295:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:18295:2: ( ruleXExpression )
+ // InternalOXtype.g:18296:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XSynchronizedExpression__ExpressionAssignment_3"
+
+
+ // $ANTLR start "rule__XCatchClause__DeclaredParamAssignment_2"
+ // InternalOXtype.g:18305:1: rule__XCatchClause__DeclaredParamAssignment_2 : ( ruleFullJvmFormalParameter ) ;
+ public final void rule__XCatchClause__DeclaredParamAssignment_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18309:1: ( ( ruleFullJvmFormalParameter ) )
+ // InternalOXtype.g:18310:2: ( ruleFullJvmFormalParameter )
+ {
+ // InternalOXtype.g:18310:2: ( ruleFullJvmFormalParameter )
+ // InternalOXtype.g:18311:3: ruleFullJvmFormalParameter
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleFullJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCatchClause__DeclaredParamAssignment_2"
+
+
+ // $ANTLR start "rule__XCatchClause__ExpressionAssignment_4"
+ // InternalOXtype.g:18320:1: rule__XCatchClause__ExpressionAssignment_4 : ( ruleXExpression ) ;
+ public final void rule__XCatchClause__ExpressionAssignment_4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18324:1: ( ( ruleXExpression ) )
+ // InternalOXtype.g:18325:2: ( ruleXExpression )
+ {
+ // InternalOXtype.g:18325:2: ( ruleXExpression )
+ // InternalOXtype.g:18326:3: ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XCatchClause__ExpressionAssignment_4"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0"
+ // InternalOXtype.g:18335:1: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 : ( ruleJvmTypeReference ) ;
+ public final void rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18339:1: ( ( ruleJvmTypeReference ) )
+ // InternalOXtype.g:18340:2: ( ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:18340:2: ( ruleJvmTypeReference )
+ // InternalOXtype.g:18341:3: ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1"
+ // InternalOXtype.g:18350:1: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 : ( ruleJvmTypeReference ) ;
+ public final void rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18354:1: ( ( ruleJvmTypeReference ) )
+ // InternalOXtype.g:18355:2: ( ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:18355:2: ( ruleJvmTypeReference )
+ // InternalOXtype.g:18356:3: ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1"
+
+
+ // $ANTLR start "rule__XFunctionTypeRef__ReturnTypeAssignment_2"
+ // InternalOXtype.g:18365:1: rule__XFunctionTypeRef__ReturnTypeAssignment_2 : ( ruleJvmTypeReference ) ;
+ public final void rule__XFunctionTypeRef__ReturnTypeAssignment_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18369:1: ( ( ruleJvmTypeReference ) )
+ // InternalOXtype.g:18370:2: ( ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:18370:2: ( ruleJvmTypeReference )
+ // InternalOXtype.g:18371:3: ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__XFunctionTypeRef__ReturnTypeAssignment_2"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__TypeAssignment_0"
+ // InternalOXtype.g:18380:1: rule__JvmParameterizedTypeReference__TypeAssignment_0 : ( ( ruleQualifiedName ) ) ;
+ public final void rule__JvmParameterizedTypeReference__TypeAssignment_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18384:1: ( ( ( ruleQualifiedName ) ) )
+ // InternalOXtype.g:18385:2: ( ( ruleQualifiedName ) )
+ {
+ // InternalOXtype.g:18385:2: ( ( ruleQualifiedName ) )
+ // InternalOXtype.g:18386:3: ( ruleQualifiedName )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0());
+ }
+ // InternalOXtype.g:18387:3: ( ruleQualifiedName )
+ // InternalOXtype.g:18388:4: ruleQualifiedName
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleQualifiedName();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__TypeAssignment_0"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1"
+ // InternalOXtype.g:18399:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 : ( ruleJvmArgumentTypeReference ) ;
+ public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18403:1: ( ( ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:18404:2: ( ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:18404:2: ( ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:18405:3: ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1"
+ // InternalOXtype.g:18414:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 : ( ruleJvmArgumentTypeReference ) ;
+ public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18418:1: ( ( ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:18419:2: ( ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:18419:2: ( ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:18420:3: ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1"
+ // InternalOXtype.g:18429:1: rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 : ( ( ruleValidID ) ) ;
+ public final void rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18433:1: ( ( ( ruleValidID ) ) )
+ // InternalOXtype.g:18434:2: ( ( ruleValidID ) )
+ {
+ // InternalOXtype.g:18434:2: ( ( ruleValidID ) )
+ // InternalOXtype.g:18435:3: ( ruleValidID )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0());
+ }
+ // InternalOXtype.g:18436:3: ( ruleValidID )
+ // InternalOXtype.g:18437:4: ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1());
+ }
+ pushFollow(FOLLOW_2);
+ ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1"
+ // InternalOXtype.g:18448:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 : ( ruleJvmArgumentTypeReference ) ;
+ public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18452:1: ( ( ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:18453:2: ( ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:18453:2: ( ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:18454:3: ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1"
+
+
+ // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1"
+ // InternalOXtype.g:18463:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 : ( ruleJvmArgumentTypeReference ) ;
+ public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18467:1: ( ( ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:18468:2: ( ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:18468:2: ( ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:18469:3: ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0"
+ // InternalOXtype.g:18478:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 : ( ruleJvmUpperBound ) ;
+ public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18482:1: ( ( ruleJvmUpperBound ) )
+ // InternalOXtype.g:18483:2: ( ruleJvmUpperBound )
+ {
+ // InternalOXtype.g:18483:2: ( ruleJvmUpperBound )
+ // InternalOXtype.g:18484:3: ruleJvmUpperBound
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmUpperBound();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1"
+ // InternalOXtype.g:18493:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 : ( ruleJvmUpperBoundAnded ) ;
+ public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18497:1: ( ( ruleJvmUpperBoundAnded ) )
+ // InternalOXtype.g:18498:2: ( ruleJvmUpperBoundAnded )
+ {
+ // InternalOXtype.g:18498:2: ( ruleJvmUpperBoundAnded )
+ // InternalOXtype.g:18499:3: ruleJvmUpperBoundAnded
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmUpperBoundAnded();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0"
+ // InternalOXtype.g:18508:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 : ( ruleJvmLowerBound ) ;
+ public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18512:1: ( ( ruleJvmLowerBound ) )
+ // InternalOXtype.g:18513:2: ( ruleJvmLowerBound )
+ {
+ // InternalOXtype.g:18513:2: ( ruleJvmLowerBound )
+ // InternalOXtype.g:18514:3: ruleJvmLowerBound
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmLowerBound();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0"
+
+
+ // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1"
+ // InternalOXtype.g:18523:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 : ( ruleJvmLowerBoundAnded ) ;
+ public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18527:1: ( ( ruleJvmLowerBoundAnded ) )
+ // InternalOXtype.g:18528:2: ( ruleJvmLowerBoundAnded )
+ {
+ // InternalOXtype.g:18528:2: ( ruleJvmLowerBoundAnded )
+ // InternalOXtype.g:18529:3: ruleJvmLowerBoundAnded
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmLowerBoundAnded();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1"
+
+
+ // $ANTLR start "rule__JvmUpperBound__TypeReferenceAssignment_1"
+ // InternalOXtype.g:18538:1: rule__JvmUpperBound__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ;
+ public final void rule__JvmUpperBound__TypeReferenceAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18542:1: ( ( ruleJvmTypeReference ) )
+ // InternalOXtype.g:18543:2: ( ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:18543:2: ( ruleJvmTypeReference )
+ // InternalOXtype.g:18544:3: ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmUpperBound__TypeReferenceAssignment_1"
+
+
+ // $ANTLR start "rule__JvmUpperBoundAnded__TypeReferenceAssignment_1"
+ // InternalOXtype.g:18553:1: rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ;
+ public final void rule__JvmUpperBoundAnded__TypeReferenceAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18557:1: ( ( ruleJvmTypeReference ) )
+ // InternalOXtype.g:18558:2: ( ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:18558:2: ( ruleJvmTypeReference )
+ // InternalOXtype.g:18559:3: ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmUpperBoundAnded__TypeReferenceAssignment_1"
+
+
+ // $ANTLR start "rule__JvmLowerBound__TypeReferenceAssignment_1"
+ // InternalOXtype.g:18568:1: rule__JvmLowerBound__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ;
+ public final void rule__JvmLowerBound__TypeReferenceAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18572:1: ( ( ruleJvmTypeReference ) )
+ // InternalOXtype.g:18573:2: ( ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:18573:2: ( ruleJvmTypeReference )
+ // InternalOXtype.g:18574:3: ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmLowerBound__TypeReferenceAssignment_1"
+
+
+ // $ANTLR start "rule__JvmLowerBoundAnded__TypeReferenceAssignment_1"
+ // InternalOXtype.g:18583:1: rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ;
+ public final void rule__JvmLowerBoundAnded__TypeReferenceAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // InternalOXtype.g:18587:1: ( ( ruleJvmTypeReference ) )
+ // InternalOXtype.g:18588:2: ( ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:18588:2: ( ruleJvmTypeReference )
+ // InternalOXtype.g:18589:3: ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_2);
+ ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JvmLowerBoundAnded__TypeReferenceAssignment_1"
+
+ // $ANTLR start synpred6_InternalOXtype
+ public final void synpred6_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2127:2: ( ( ( rule__XAnnotation__Group_3_1_0__0 ) ) )
+ // InternalOXtype.g:2127:2: ( ( rule__XAnnotation__Group_3_1_0__0 ) )
+ {
+ // InternalOXtype.g:2127:2: ( ( rule__XAnnotation__Group_3_1_0__0 ) )
+ // InternalOXtype.g:2128:3: ( rule__XAnnotation__Group_3_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationAccess().getGroup_3_1_0());
+ }
+ // InternalOXtype.g:2129:3: ( rule__XAnnotation__Group_3_1_0__0 )
+ // InternalOXtype.g:2129:4: rule__XAnnotation__Group_3_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotation__Group_3_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred6_InternalOXtype
+
+ // $ANTLR start synpred7_InternalOXtype
+ public final void synpred7_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2148:2: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) ) )
+ // InternalOXtype.g:2148:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) )
+ {
+ // InternalOXtype.g:2148:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) )
+ // InternalOXtype.g:2149:3: ( rule__XAnnotationElementValueOrCommaList__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0());
+ }
+ // InternalOXtype.g:2150:3: ( rule__XAnnotationElementValueOrCommaList__Group_0__0 )
+ // InternalOXtype.g:2150:4: rule__XAnnotationElementValueOrCommaList__Group_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValueOrCommaList__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred7_InternalOXtype
+
+ // $ANTLR start synpred8_InternalOXtype
+ public final void synpred8_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2169:2: ( ( ( rule__XAnnotationElementValue__Group_0__0 ) ) )
+ // InternalOXtype.g:2169:2: ( ( rule__XAnnotationElementValue__Group_0__0 ) )
+ {
+ // InternalOXtype.g:2169:2: ( ( rule__XAnnotationElementValue__Group_0__0 ) )
+ // InternalOXtype.g:2170:3: ( rule__XAnnotationElementValue__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0());
+ }
+ // InternalOXtype.g:2171:3: ( rule__XAnnotationElementValue__Group_0__0 )
+ // InternalOXtype.g:2171:4: rule__XAnnotationElementValue__Group_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAnnotationElementValue__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred8_InternalOXtype
+
+ // $ANTLR start synpred33_InternalOXtype
+ public final void synpred33_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2454:2: ( ( ( rule__OpOther__Group_6_1_0__0 ) ) )
+ // InternalOXtype.g:2454:2: ( ( rule__OpOther__Group_6_1_0__0 ) )
+ {
+ // InternalOXtype.g:2454:2: ( ( rule__OpOther__Group_6_1_0__0 ) )
+ // InternalOXtype.g:2455:3: ( rule__OpOther__Group_6_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getGroup_6_1_0());
+ }
+ // InternalOXtype.g:2456:3: ( rule__OpOther__Group_6_1_0__0 )
+ // InternalOXtype.g:2456:4: rule__OpOther__Group_6_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__OpOther__Group_6_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred33_InternalOXtype
+
+ // $ANTLR start synpred34_InternalOXtype
+ public final void synpred34_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2460:2: ( ( '<' ) )
+ // InternalOXtype.g:2460:2: ( '<' )
+ {
+ // InternalOXtype.g:2460:2: ( '<' )
+ // InternalOXtype.g:2461:3: '<'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1());
+ }
+ match(input,27,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred34_InternalOXtype
+
+ // $ANTLR start synpred47_InternalOXtype
+ public final void synpred47_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2673:2: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) )
+ // InternalOXtype.g:2673:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) )
+ {
+ // InternalOXtype.g:2673:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) )
+ // InternalOXtype.g:2674:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0());
+ }
+ // InternalOXtype.g:2675:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 )
+ // InternalOXtype.g:2675:4: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred47_InternalOXtype
+
+ // $ANTLR start synpred55_InternalOXtype
+ public final void synpred55_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2736:2: ( ( ( ruleXForLoopExpression ) ) )
+ // InternalOXtype.g:2736:2: ( ( ruleXForLoopExpression ) )
+ {
+ // InternalOXtype.g:2736:2: ( ( ruleXForLoopExpression ) )
+ // InternalOXtype.g:2737:3: ( ruleXForLoopExpression )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7());
+ }
+ // InternalOXtype.g:2738:3: ( ruleXForLoopExpression )
+ // InternalOXtype.g:2738:4: ruleXForLoopExpression
+ {
+ pushFollow(FOLLOW_2);
+ ruleXForLoopExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred55_InternalOXtype
+
+ // $ANTLR start synpred56_InternalOXtype
+ public final void synpred56_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2742:2: ( ( ruleXBasicForLoopExpression ) )
+ // InternalOXtype.g:2742:2: ( ruleXBasicForLoopExpression )
+ {
+ // InternalOXtype.g:2742:2: ( ruleXBasicForLoopExpression )
+ // InternalOXtype.g:2743:3: ruleXBasicForLoopExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8());
+ }
+ pushFollow(FOLLOW_2);
+ ruleXBasicForLoopExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred56_InternalOXtype
+
+ // $ANTLR start synpred69_InternalOXtype
+ public final void synpred69_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2865:2: ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) )
+ // InternalOXtype.g:2865:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) )
+ {
+ // InternalOXtype.g:2865:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) )
+ // InternalOXtype.g:2866:3: ( rule__XSwitchExpression__Group_2_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0());
+ }
+ // InternalOXtype.g:2867:3: ( rule__XSwitchExpression__Group_2_0__0 )
+ // InternalOXtype.g:2867:4: rule__XSwitchExpression__Group_2_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred69_InternalOXtype
+
+ // $ANTLR start synpred73_InternalOXtype
+ public final void synpred73_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2949:2: ( ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) )
+ // InternalOXtype.g:2949:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) )
+ {
+ // InternalOXtype.g:2949:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) )
+ // InternalOXtype.g:2950:3: ( rule__XVariableDeclaration__Group_2_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0());
+ }
+ // InternalOXtype.g:2951:3: ( rule__XVariableDeclaration__Group_2_0__0 )
+ // InternalOXtype.g:2951:4: rule__XVariableDeclaration__Group_2_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XVariableDeclaration__Group_2_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred73_InternalOXtype
+
+ // $ANTLR start synpred74_InternalOXtype
+ public final void synpred74_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2970:2: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) )
+ // InternalOXtype.g:2970:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) )
+ {
+ // InternalOXtype.g:2970:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) )
+ // InternalOXtype.g:2971:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0());
+ }
+ // InternalOXtype.g:2972:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 )
+ // InternalOXtype.g:2972:4: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred74_InternalOXtype
+
+ // $ANTLR start synpred80_InternalOXtype
+ public final void synpred80_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:3051:2: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) )
+ // InternalOXtype.g:3051:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) )
+ {
+ // InternalOXtype.g:3051:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) )
+ // InternalOXtype.g:3052:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0());
+ }
+ // InternalOXtype.g:3053:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 )
+ // InternalOXtype.g:3053:4: rule__XConstructorCall__ArgumentsAssignment_4_1_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__ArgumentsAssignment_4_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred80_InternalOXtype
+
+ // $ANTLR start synpred100_InternalOXtype
+ public final void synpred100_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:4853:3: ( rule__XAssignment__Group_1_1__0 )
+ // InternalOXtype.g:4853:3: rule__XAssignment__Group_1_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAssignment__Group_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred100_InternalOXtype
+
+ // $ANTLR start synpred102_InternalOXtype
+ public final void synpred102_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:5204:3: ( rule__XOrExpression__Group_1__0 )
+ // InternalOXtype.g:5204:3: rule__XOrExpression__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOrExpression__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred102_InternalOXtype
+
+ // $ANTLR start synpred103_InternalOXtype
+ public final void synpred103_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:5393:3: ( rule__XAndExpression__Group_1__0 )
+ // InternalOXtype.g:5393:3: rule__XAndExpression__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAndExpression__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred103_InternalOXtype
+
+ // $ANTLR start synpred104_InternalOXtype
+ public final void synpred104_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:5582:3: ( rule__XEqualityExpression__Group_1__0 )
+ // InternalOXtype.g:5582:3: rule__XEqualityExpression__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XEqualityExpression__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred104_InternalOXtype
+
+ // $ANTLR start synpred105_InternalOXtype
+ public final void synpred105_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:5771:3: ( rule__XRelationalExpression__Alternatives_1 )
+ // InternalOXtype.g:5771:3: rule__XRelationalExpression__Alternatives_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XRelationalExpression__Alternatives_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred105_InternalOXtype
+
+ // $ANTLR start synpred106_InternalOXtype
+ public final void synpred106_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:6149:3: ( rule__XOtherOperatorExpression__Group_1__0 )
+ // InternalOXtype.g:6149:3: rule__XOtherOperatorExpression__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XOtherOperatorExpression__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred106_InternalOXtype
+
+ // $ANTLR start synpred107_InternalOXtype
+ public final void synpred107_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:6662:3: ( rule__XAdditiveExpression__Group_1__0 )
+ // InternalOXtype.g:6662:3: rule__XAdditiveExpression__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XAdditiveExpression__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred107_InternalOXtype
+
+ // $ANTLR start synpred108_InternalOXtype
+ public final void synpred108_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:6851:3: ( rule__XMultiplicativeExpression__Group_1__0 )
+ // InternalOXtype.g:6851:3: rule__XMultiplicativeExpression__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMultiplicativeExpression__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred108_InternalOXtype
+
+ // $ANTLR start synpred109_InternalOXtype
+ public final void synpred109_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:7121:3: ( rule__XCastedExpression__Group_1__0 )
+ // InternalOXtype.g:7121:3: rule__XCastedExpression__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XCastedExpression__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred109_InternalOXtype
+
+ // $ANTLR start synpred110_InternalOXtype
+ public final void synpred110_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:7310:3: ( rule__XPostfixOperation__Group_1__0 )
+ // InternalOXtype.g:7310:3: rule__XPostfixOperation__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XPostfixOperation__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred110_InternalOXtype
+
+ // $ANTLR start synpred111_InternalOXtype
+ public final void synpred111_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:7445:3: ( rule__XMemberFeatureCall__Alternatives_1 )
+ // InternalOXtype.g:7445:3: rule__XMemberFeatureCall__Alternatives_1
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Alternatives_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred111_InternalOXtype
+
+ // $ANTLR start synpred113_InternalOXtype
+ public final void synpred113_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:7743:3: ( rule__XMemberFeatureCall__Group_1_1_3__0 )
+ // InternalOXtype.g:7743:3: rule__XMemberFeatureCall__Group_1_1_3__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__Group_1_1_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred113_InternalOXtype
+
+ // $ANTLR start synpred114_InternalOXtype
+ public final void synpred114_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:7769:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )
+ // InternalOXtype.g:7769:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4
+ {
+ pushFollow(FOLLOW_2);
+ rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred114_InternalOXtype
+
+ // $ANTLR start synpred122_InternalOXtype
+ public final void synpred122_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:8742:3: ( rule__XClosure__Group_1__0 )
+ // InternalOXtype.g:8742:3: rule__XClosure__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XClosure__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred122_InternalOXtype
+
+ // $ANTLR start synpred129_InternalOXtype
+ public final void synpred129_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:9713:3: ( rule__XIfExpression__Group_6__0 )
+ // InternalOXtype.g:9713:3: rule__XIfExpression__Group_6__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XIfExpression__Group_6__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred129_InternalOXtype
+
+ // $ANTLR start synpred132_InternalOXtype
+ public final void synpred132_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:10173:3: ( rule__XSwitchExpression__Group_2_1_0__0 )
+ // InternalOXtype.g:10173:3: rule__XSwitchExpression__Group_2_1_0__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XSwitchExpression__Group_2_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred132_InternalOXtype
+
+ // $ANTLR start synpred145_InternalOXtype
+ public final void synpred145_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:12306:3: ( rule__XFeatureCall__Group_3__0 )
+ // InternalOXtype.g:12306:3: rule__XFeatureCall__Group_3__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__Group_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred145_InternalOXtype
+
+ // $ANTLR start synpred146_InternalOXtype
+ public final void synpred146_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:12332:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )
+ // InternalOXtype.g:12332:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_4
+ {
+ pushFollow(FOLLOW_2);
+ rule__XFeatureCall__FeatureCallArgumentsAssignment_4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred146_InternalOXtype
+
+ // $ANTLR start synpred150_InternalOXtype
+ public final void synpred150_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:12792:3: ( rule__XConstructorCall__Group_3__0 )
+ // InternalOXtype.g:12792:3: rule__XConstructorCall__Group_3__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred150_InternalOXtype
+
+ // $ANTLR start synpred151_InternalOXtype
+ public final void synpred151_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:12819:3: ( rule__XConstructorCall__Group_4__0 )
+ // InternalOXtype.g:12819:3: rule__XConstructorCall__Group_4__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__Group_4__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred151_InternalOXtype
+
+ // $ANTLR start synpred152_InternalOXtype
+ public final void synpred152_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:12845:3: ( rule__XConstructorCall__ArgumentsAssignment_5 )
+ // InternalOXtype.g:12845:3: rule__XConstructorCall__ArgumentsAssignment_5
+ {
+ pushFollow(FOLLOW_2);
+ rule__XConstructorCall__ArgumentsAssignment_5();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred152_InternalOXtype
+
+ // $ANTLR start synpred157_InternalOXtype
+ public final void synpred157_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:13736:3: ( rule__XReturnExpression__ExpressionAssignment_2 )
+ // InternalOXtype.g:13736:3: rule__XReturnExpression__ExpressionAssignment_2
+ {
+ pushFollow(FOLLOW_2);
+ rule__XReturnExpression__ExpressionAssignment_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred157_InternalOXtype
+
+ // $ANTLR start synpred158_InternalOXtype
+ public final void synpred158_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:13878:4: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )
+ // InternalOXtype.g:13878:4: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred158_InternalOXtype
+
+ // $ANTLR start synpred159_InternalOXtype
+ public final void synpred159_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:13905:3: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )
+ // InternalOXtype.g:13905:3: rule__XTryCatchFinallyExpression__Group_3_0_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__XTryCatchFinallyExpression__Group_3_0_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred159_InternalOXtype
+
+ // $ANTLR start synpred160_InternalOXtype
+ public final void synpred160_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:14418:3: ( rule__QualifiedName__Group_1__0 )
+ // InternalOXtype.g:14418:3: rule__QualifiedName__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__QualifiedName__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred160_InternalOXtype
+
+ // $ANTLR start synpred162_InternalOXtype
+ public final void synpred162_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:14634:3: ( rule__JvmTypeReference__Group_0_1__0 )
+ // InternalOXtype.g:14634:3: rule__JvmTypeReference__Group_0_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmTypeReference__Group_0_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred162_InternalOXtype
+
+ // $ANTLR start synpred166_InternalOXtype
+ public final void synpred166_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:15093:3: ( rule__JvmParameterizedTypeReference__Group_1__0 )
+ // InternalOXtype.g:15093:3: rule__JvmParameterizedTypeReference__Group_1__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred166_InternalOXtype
+
+ // $ANTLR start synpred168_InternalOXtype
+ public final void synpred168_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:15228:3: ( rule__JvmParameterizedTypeReference__Group_1_4__0 )
+ // InternalOXtype.g:15228:3: rule__JvmParameterizedTypeReference__Group_1_4__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_4__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred168_InternalOXtype
+
+ // $ANTLR start synpred169_InternalOXtype
+ public final void synpred169_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:15363:3: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )
+ // InternalOXtype.g:15363:3: rule__JvmParameterizedTypeReference__Group_1_4_2__0
+ {
+ pushFollow(FOLLOW_2);
+ rule__JvmParameterizedTypeReference__Group_1_4_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred169_InternalOXtype
+
+ // Delegated rules
+
+ public final boolean synpred114_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred114_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred73_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred73_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred152_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred152_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred8_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred8_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred160_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred160_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred157_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred157_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred69_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred69_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred169_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred169_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred122_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred122_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred105_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred105_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred56_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred56_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred107_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred107_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred74_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred74_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred102_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred102_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred110_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred110_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred145_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred145_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred158_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred158_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred162_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred162_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred132_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred132_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred166_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred166_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred106_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred106_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred146_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred146_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred33_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred33_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred159_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred159_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred129_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred129_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred150_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred150_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred111_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred111_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred103_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred103_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred109_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred109_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred7_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred7_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred47_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred47_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred80_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred80_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred100_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred100_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred34_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred34_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred113_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred113_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred168_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred168_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred104_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred104_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred6_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred6_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred151_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred151_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred55_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred55_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred108_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred108_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+
+
+ protected DFA2 dfa2 = new DFA2(this);
+ protected DFA4 dfa4 = new DFA4(this);
+ protected DFA5 dfa5 = new DFA5(this);
+ protected DFA6 dfa6 = new DFA6(this);
+ protected DFA13 dfa13 = new DFA13(this);
+ protected DFA21 dfa21 = new DFA21(this);
+ protected DFA24 dfa24 = new DFA24(this);
+ protected DFA25 dfa25 = new DFA25(this);
+ protected DFA28 dfa28 = new DFA28(this);
+ protected DFA33 dfa33 = new DFA33(this);
+ protected DFA36 dfa36 = new DFA36(this);
+ protected DFA56 dfa56 = new DFA56(this);
+ protected DFA62 dfa62 = new DFA62(this);
+ protected DFA69 dfa69 = new DFA69(this);
+ protected DFA70 dfa70 = new DFA70(this);
+ protected DFA78 dfa78 = new DFA78(this);
+ protected DFA88 dfa88 = new DFA88(this);
+ protected DFA101 dfa101 = new DFA101(this);
+ protected DFA102 dfa102 = new DFA102(this);
+ protected DFA106 dfa106 = new DFA106(this);
+ protected DFA107 dfa107 = new DFA107(this);
+ protected DFA108 dfa108 = new DFA108(this);
+ protected DFA113 dfa113 = new DFA113(this);
+ protected DFA122 dfa122 = new DFA122(this);
+ protected DFA125 dfa125 = new DFA125(this);
+ static final String dfa_1s = "\10\uffff";
+ static final String dfa_2s = "\2\uffff\1\5\4\uffff\1\5";
+ static final String dfa_3s = "\1\4\1\uffff\1\53\1\uffff\1\4\2\uffff\1\53";
+ static final String dfa_4s = "\1\123\1\uffff\1\63\1\uffff\1\44\2\uffff\1\63";
+ static final String dfa_5s = "\1\uffff\1\1\1\uffff\1\4\1\uffff\1\2\1\3\1\uffff";
+ static final String dfa_6s = "\10\uffff}>";
+ static final String[] dfa_7s = {
+ "\1\2\51\uffff\1\1\44\uffff\1\3",
+ "",
+ "\1\4\7\uffff\1\5",
+ "",
+ "\1\7\37\uffff\1\6",
+ "",
+ "",
+ "\1\4\7\uffff\1\5"
+ };
+
+ static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s);
+ static final short[] dfa_2 = DFA.unpackEncodedString(dfa_2s);
+ static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s);
+ static final char[] dfa_4 = DFA.unpackEncodedStringToUnsignedChars(dfa_4s);
+ static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s);
+ static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s);
+ static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s);
+
+ class DFA2 extends DFA {
+
+ public DFA2(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 2;
+ this.eot = dfa_1;
+ this.eof = dfa_2;
+ this.min = dfa_3;
+ this.max = dfa_4;
+ this.accept = dfa_5;
+ this.special = dfa_6;
+ this.transition = dfa_7;
+ }
+ public String getDescription() {
+ return "2068:1: rule__XImportDeclaration__Alternatives_2 : ( ( ( rule__XImportDeclaration__Group_2_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_2_2 ) ) | ( ( rule__XImportDeclaration__Group_2_3__0 ) ) );";
+ }
+ }
+ static final String dfa_8s = "\43\uffff";
+ static final String dfa_9s = "\1\4\1\0\41\uffff";
+ static final String dfa_10s = "\1\130\1\0\41\uffff";
+ static final String dfa_11s = "\2\uffff\1\2\37\uffff\1\1";
+ static final String dfa_12s = "\1\uffff\1\0\41\uffff}>";
+ static final String[] dfa_13s = {
+ "\1\1\4\2\22\uffff\1\2\6\uffff\2\2\4\uffff\1\2\4\uffff\6\2\1\uffff\2\2\3\uffff\2\2\2\uffff\1\2\1\uffff\1\2\1\uffff\1\2\3\uffff\11\2\1\uffff\1\2\10\uffff\1\2",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] dfa_8 = DFA.unpackEncodedString(dfa_8s);
+ static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s);
+ static final char[] dfa_10 = DFA.unpackEncodedStringToUnsignedChars(dfa_10s);
+ static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s);
+ static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s);
+ static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s);
+
+ class DFA4 extends DFA {
+
+ public DFA4(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 4;
+ this.eot = dfa_8;
+ this.eof = dfa_8;
+ this.min = dfa_9;
+ this.max = dfa_10;
+ this.accept = dfa_11;
+ this.special = dfa_12;
+ this.transition = dfa_13;
+ }
+ public String getDescription() {
+ return "2122:1: rule__XAnnotation__Alternatives_3_1 : ( ( ( rule__XAnnotation__Group_3_1_0__0 ) ) | ( ( rule__XAnnotation__ValueAssignment_3_1_1 ) ) );";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA4_1 = input.LA(1);
+
+
+ int index4_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred6_InternalOXtype()) ) {s = 34;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index4_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 4, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String[] dfa_14s = {
+ "\5\2\22\uffff\1\2\6\uffff\2\2\4\uffff\1\2\4\uffff\6\2\1\uffff\2\2\3\uffff\1\1\1\2\2\uffff\1\2\1\uffff\1\2\1\uffff\1\2\3\uffff\11\2\1\uffff\1\2\10\uffff\1\2",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+ static final short[][] dfa_14 = unpackEncodedStringArray(dfa_14s);
+
+ class DFA5 extends DFA {
+
+ public DFA5(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 5;
+ this.eot = dfa_8;
+ this.eof = dfa_8;
+ this.min = dfa_9;
+ this.max = dfa_10;
+ this.accept = dfa_11;
+ this.special = dfa_12;
+ this.transition = dfa_14;
+ }
+ public String getDescription() {
+ return "2143:1: rule__XAnnotationElementValueOrCommaList__Alternatives : ( ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) ) | ( ( rule__XAnnotationElementValueOrCommaList__Group_1__0 ) ) );";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA5_1 = input.LA(1);
+
+
+ int index5_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred7_InternalOXtype()) ) {s = 34;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index5_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 5, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+ class DFA6 extends DFA {
+
+ public DFA6(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 6;
+ this.eot = dfa_8;
+ this.eof = dfa_8;
+ this.min = dfa_9;
+ this.max = dfa_10;
+ this.accept = dfa_11;
+ this.special = dfa_12;
+ this.transition = dfa_14;
+ }
+ public String getDescription() {
+ return "2164:1: rule__XAnnotationElementValue__Alternatives : ( ( ( rule__XAnnotationElementValue__Group_0__0 ) ) | ( ruleXAnnotationOrExpression ) );";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA6_1 = input.LA(1);
+
+
+ int index6_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred8_InternalOXtype()) ) {s = 34;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index6_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 6, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_15s = "\13\uffff";
+ static final String dfa_16s = "\1\32\2\uffff\1\32\7\uffff";
+ static final String dfa_17s = "\1\41\2\uffff\1\36\7\uffff";
+ static final String dfa_18s = "\1\uffff\1\1\1\2\1\uffff\1\4\1\5\1\7\1\10\1\11\1\6\1\3";
+ static final String dfa_19s = "\13\uffff}>";
+ static final String[] dfa_20s = {
+ "\1\3\1\6\1\1\1\2\1\4\1\5\1\7\1\10",
+ "",
+ "",
+ "\1\11\3\uffff\1\12",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] dfa_15 = DFA.unpackEncodedString(dfa_15s);
+ static final char[] dfa_16 = DFA.unpackEncodedStringToUnsignedChars(dfa_16s);
+ static final char[] dfa_17 = DFA.unpackEncodedStringToUnsignedChars(dfa_17s);
+ static final short[] dfa_18 = DFA.unpackEncodedString(dfa_18s);
+ static final short[] dfa_19 = DFA.unpackEncodedString(dfa_19s);
+ static final short[][] dfa_20 = unpackEncodedStringArray(dfa_20s);
+
+ class DFA13 extends DFA {
+
+ public DFA13(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 13;
+ this.eot = dfa_15;
+ this.eof = dfa_15;
+ this.min = dfa_16;
+ this.max = dfa_17;
+ this.accept = dfa_18;
+ this.special = dfa_19;
+ this.transition = dfa_20;
+ }
+ public String getDescription() {
+ return "2365:1: rule__OpOther__Alternatives : ( ( '->' ) | ( '..<' ) | ( ( rule__OpOther__Group_2__0 ) ) | ( '..' ) | ( '=>' ) | ( ( rule__OpOther__Group_5__0 ) ) | ( ( rule__OpOther__Group_6__0 ) ) | ( '<>' ) | ( '?:' ) );";
+ }
+ }
+ static final String dfa_21s = "\12\uffff";
+ static final String dfa_22s = "\4\uffff\5\3\1\uffff";
+ static final String dfa_23s = "\1\53\2\4\1\uffff\5\4\1\uffff";
+ static final String dfa_24s = "\1\125\2\61\1\uffff\5\130\1\uffff";
+ static final String dfa_25s = "\3\uffff\1\2\5\uffff\1\1";
+ static final String dfa_26s = "\12\uffff}>";
+ static final String[] dfa_27s = {
+ "\1\1\50\uffff\1\2\1\3",
+ "\1\4\26\uffff\1\3\21\uffff\1\5\1\6\1\7\1\10\1\3",
+ "\1\4\26\uffff\1\3\21\uffff\1\5\1\6\1\7\1\10\1\3",
+ "",
+ "\5\3\4\uffff\1\11\46\3\1\uffff\34\3\3\uffff\2\3\1\uffff\2\3",
+ "\5\3\4\uffff\1\11\46\3\1\uffff\34\3\3\uffff\2\3\1\uffff\2\3",
+ "\5\3\4\uffff\1\11\46\3\1\uffff\34\3\3\uffff\2\3\1\uffff\2\3",
+ "\5\3\4\uffff\1\11\46\3\1\uffff\34\3\3\uffff\2\3\1\uffff\2\3",
+ "\5\3\4\uffff\1\11\46\3\1\uffff\34\3\3\uffff\2\3\1\uffff\2\3",
+ ""
+ };
+
+ static final short[] dfa_21 = DFA.unpackEncodedString(dfa_21s);
+ static final short[] dfa_22 = DFA.unpackEncodedString(dfa_22s);
+ static final char[] dfa_23 = DFA.unpackEncodedStringToUnsignedChars(dfa_23s);
+ static final char[] dfa_24 = DFA.unpackEncodedStringToUnsignedChars(dfa_24s);
+ static final short[] dfa_25 = DFA.unpackEncodedString(dfa_25s);
+ static final short[] dfa_26 = DFA.unpackEncodedString(dfa_26s);
+ static final short[][] dfa_27 = unpackEncodedStringArray(dfa_27s);
+
+ class DFA21 extends DFA {
+
+ public DFA21(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 21;
+ this.eot = dfa_21;
+ this.eof = dfa_22;
+ this.min = dfa_23;
+ this.max = dfa_24;
+ this.accept = dfa_25;
+ this.special = dfa_26;
+ this.transition = dfa_27;
+ }
+ public String getDescription() {
+ return "2599:1: rule__XMemberFeatureCall__Alternatives_1 : ( ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) );";
+ }
+ }
+ static final String dfa_28s = "\1\4\2\0\40\uffff";
+ static final String dfa_29s = "\1\130\2\0\40\uffff";
+ static final String dfa_30s = "\3\uffff\1\1\1\uffff\1\2\35\uffff";
+ static final String dfa_31s = "\1\uffff\1\0\1\1\40\uffff}>";
+ static final String[] dfa_32s = {
+ "\1\1\4\5\22\uffff\1\5\3\uffff\1\3\2\uffff\2\5\4\uffff\1\5\4\uffff\6\5\2\uffff\1\2\3\uffff\2\5\2\uffff\1\5\1\uffff\1\5\1\uffff\1\5\3\uffff\11\5\1\uffff\1\5\6\uffff\1\3\1\uffff\1\5",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+ static final char[] dfa_28 = DFA.unpackEncodedStringToUnsignedChars(dfa_28s);
+ static final char[] dfa_29 = DFA.unpackEncodedStringToUnsignedChars(dfa_29s);
+ static final short[] dfa_30 = DFA.unpackEncodedString(dfa_30s);
+ static final short[] dfa_31 = DFA.unpackEncodedString(dfa_31s);
+ static final short[][] dfa_32 = unpackEncodedStringArray(dfa_32s);
+
+ class DFA24 extends DFA {
+
+ public DFA24(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 24;
+ this.eot = dfa_8;
+ this.eof = dfa_8;
+ this.min = dfa_28;
+ this.max = dfa_29;
+ this.accept = dfa_30;
+ this.special = dfa_31;
+ this.transition = dfa_32;
+ }
+ public String getDescription() {
+ return "2668:1: rule__XMemberFeatureCall__Alternatives_1_1_3_1 : ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) );";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA24_1 = input.LA(1);
+
+
+ int index24_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred47_InternalOXtype()) ) {s = 3;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index24_1);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA24_2 = input.LA(1);
+
+
+ int index24_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred47_InternalOXtype()) ) {s = 3;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index24_2);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 24, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_33s = "\40\uffff";
+ static final String dfa_34s = "\1\4\26\uffff\1\0\10\uffff";
+ static final String dfa_35s = "\1\130\26\uffff\1\0\10\uffff";
+ static final String dfa_36s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\6\uffff\1\6\11\uffff\1\7\1\uffff\1\12\1\13\1\14\1\15\1\16\1\17\1\10\1\11";
+ static final String dfa_37s = "\27\uffff\1\0\10\uffff}>";
+ static final String[] dfa_38s = {
+ "\1\5\4\14\22\uffff\1\5\21\uffff\5\5\1\14\2\uffff\1\35\3\uffff\2\14\2\uffff\1\2\1\uffff\1\26\1\uffff\1\3\3\uffff\1\27\1\30\1\31\1\1\2\14\1\32\1\33\1\34\1\uffff\1\4\10\uffff\1\14",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] dfa_33 = DFA.unpackEncodedString(dfa_33s);
+ static final char[] dfa_34 = DFA.unpackEncodedStringToUnsignedChars(dfa_34s);
+ static final char[] dfa_35 = DFA.unpackEncodedStringToUnsignedChars(dfa_35s);
+ static final short[] dfa_36 = DFA.unpackEncodedString(dfa_36s);
+ static final short[] dfa_37 = DFA.unpackEncodedString(dfa_37s);
+ static final short[][] dfa_38 = unpackEncodedStringArray(dfa_38s);
+
+ class DFA25 extends DFA {
+
+ public DFA25(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 25;
+ this.eot = dfa_33;
+ this.eof = dfa_33;
+ this.min = dfa_34;
+ this.max = dfa_35;
+ this.accept = dfa_36;
+ this.special = dfa_37;
+ this.transition = dfa_38;
+ }
+ public String getDescription() {
+ return "2689:1: rule__XPrimaryExpression__Alternatives : ( ( ruleXConstructorCall ) | ( ruleXBlockExpression ) | ( ruleXSwitchExpression ) | ( ( ruleXSynchronizedExpression ) ) | ( ruleXFeatureCall ) | ( ruleXLiteral ) | ( ruleXIfExpression ) | ( ( ruleXForLoopExpression ) ) | ( ruleXBasicForLoopExpression ) | ( ruleXWhileExpression ) | ( ruleXDoWhileExpression ) | ( ruleXThrowExpression ) | ( ruleXReturnExpression ) | ( ruleXTryCatchFinallyExpression ) | ( ruleXParenthesizedExpression ) );";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA25_23 = input.LA(1);
+
+
+ int index25_23 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred55_InternalOXtype()) ) {s = 30;}
+
+ else if ( (synpred56_InternalOXtype()) ) {s = 31;}
+
+
+ input.seek(index25_23);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 25, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String[] dfa_39s = {
+ "\5\2\22\uffff\1\2\3\uffff\1\2\2\uffff\2\2\4\uffff\1\2\4\uffff\6\2\2\uffff\1\1\3\uffff\2\2\2\uffff\1\2\1\uffff\1\2\1\uffff\1\2\3\uffff\11\2\1\uffff\1\2\10\uffff\1\2",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+ static final short[][] dfa_39 = unpackEncodedStringArray(dfa_39s);
+
+ class DFA28 extends DFA {
+
+ public DFA28(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 28;
+ this.eot = dfa_8;
+ this.eof = dfa_8;
+ this.min = dfa_9;
+ this.max = dfa_10;
+ this.accept = dfa_11;
+ this.special = dfa_12;
+ this.transition = dfa_39;
+ }
+ public String getDescription() {
+ return "2860:1: rule__XSwitchExpression__Alternatives_2 : ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) | ( ( rule__XSwitchExpression__Group_2_1__0 ) ) );";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA28_1 = input.LA(1);
+
+
+ int index28_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred69_InternalOXtype()) ) {s = 34;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index28_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 28, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+ class DFA33 extends DFA {
+
+ public DFA33(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 33;
+ this.eot = dfa_8;
+ this.eof = dfa_8;
+ this.min = dfa_28;
+ this.max = dfa_29;
+ this.accept = dfa_30;
+ this.special = dfa_31;
+ this.transition = dfa_32;
+ }
+ public String getDescription() {
+ return "2965:1: rule__XFeatureCall__Alternatives_3_1 : ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) | ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) );";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA33_1 = input.LA(1);
+
+
+ int index33_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred74_InternalOXtype()) ) {s = 3;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index33_1);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA33_2 = input.LA(1);
+
+
+ int index33_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred74_InternalOXtype()) ) {s = 3;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index33_2);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 33, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+ class DFA36 extends DFA {
+
+ public DFA36(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 36;
+ this.eot = dfa_8;
+ this.eof = dfa_8;
+ this.min = dfa_28;
+ this.max = dfa_29;
+ this.accept = dfa_30;
+ this.special = dfa_31;
+ this.transition = dfa_32;
+ }
+ public String getDescription() {
+ return "3046:1: rule__XConstructorCall__Alternatives_4_1 : ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) | ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) );";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA36_1 = input.LA(1);
+
+
+ int index36_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred80_InternalOXtype()) ) {s = 3;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index36_1);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA36_2 = input.LA(1);
+
+
+ int index36_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred80_InternalOXtype()) ) {s = 3;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index36_2);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 36, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_40s = "\1\10\11\uffff";
+ static final String dfa_41s = "\1\4\7\0\2\uffff";
+ static final String dfa_42s = "\1\130\7\0\2\uffff";
+ static final String dfa_43s = "\10\uffff\1\2\1\1";
+ static final String dfa_44s = "\1\uffff\1\1\1\3\1\6\1\0\1\2\1\4\1\5\2\uffff}>";
+ static final String[] dfa_45s = {
+ "\5\10\5\uffff\2\10\1\1\1\2\1\3\1\4\1\5\5\10\1\7\1\6\30\10\1\uffff\34\10\3\uffff\2\10\1\uffff\2\10",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ ""
+ };
+ static final short[] dfa_40 = DFA.unpackEncodedString(dfa_40s);
+ static final char[] dfa_41 = DFA.unpackEncodedStringToUnsignedChars(dfa_41s);
+ static final char[] dfa_42 = DFA.unpackEncodedStringToUnsignedChars(dfa_42s);
+ static final short[] dfa_43 = DFA.unpackEncodedString(dfa_43s);
+ static final short[] dfa_44 = DFA.unpackEncodedString(dfa_44s);
+ static final short[][] dfa_45 = unpackEncodedStringArray(dfa_45s);
+
+ class DFA56 extends DFA {
+
+ public DFA56(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 56;
+ this.eot = dfa_21;
+ this.eof = dfa_40;
+ this.min = dfa_41;
+ this.max = dfa_42;
+ this.accept = dfa_43;
+ this.special = dfa_44;
+ this.transition = dfa_45;
+ }
+ public String getDescription() {
+ return "4853:2: ( rule__XAssignment__Group_1_1__0 )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA56_4 = input.LA(1);
+
+
+ int index56_4 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred100_InternalOXtype()) ) {s = 9;}
+
+ else if ( (true) ) {s = 8;}
+
+
+ input.seek(index56_4);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA56_1 = input.LA(1);
+
+
+ int index56_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred100_InternalOXtype()) ) {s = 9;}
+
+ else if ( (true) ) {s = 8;}
+
+
+ input.seek(index56_1);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA56_5 = input.LA(1);
+
+
+ int index56_5 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred100_InternalOXtype()) ) {s = 9;}
+
+ else if ( (true) ) {s = 8;}
+
+
+ input.seek(index56_5);
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA56_2 = input.LA(1);
+
+
+ int index56_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred100_InternalOXtype()) ) {s = 9;}
+
+ else if ( (true) ) {s = 8;}
+
+
+ input.seek(index56_2);
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA56_6 = input.LA(1);
+
+
+ int index56_6 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred100_InternalOXtype()) ) {s = 9;}
+
+ else if ( (true) ) {s = 8;}
+
+
+ input.seek(index56_6);
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA56_7 = input.LA(1);
+
+
+ int index56_7 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred100_InternalOXtype()) ) {s = 9;}
+
+ else if ( (true) ) {s = 8;}
+
+
+ input.seek(index56_7);
+ if ( s>=0 ) return s;
+ break;
+ case 6 :
+ int LA56_3 = input.LA(1);
+
+
+ int index56_3 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred100_InternalOXtype()) ) {s = 9;}
+
+ else if ( (true) ) {s = 8;}
+
+
+ input.seek(index56_3);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 56, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_46s = "\1\1\12\uffff";
+ static final String dfa_47s = "\1\4\1\uffff\10\0\1\uffff";
+ static final String dfa_48s = "\1\130\1\uffff\10\0\1\uffff";
+ static final String dfa_49s = "\1\uffff\1\2\10\uffff\1\1";
+ static final String dfa_50s = "\2\uffff\1\2\1\5\1\7\1\3\1\1\1\6\1\0\1\4\1\uffff}>";
+ static final String[] dfa_51s = {
+ "\5\1\5\uffff\14\1\1\3\1\2\1\4\1\5\1\6\1\7\1\10\1\11\22\1\1\uffff\34\1\3\uffff\2\1\1\uffff\2\1",
+ "",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ ""
+ };
+ static final short[] dfa_46 = DFA.unpackEncodedString(dfa_46s);
+ static final char[] dfa_47 = DFA.unpackEncodedStringToUnsignedChars(dfa_47s);
+ static final char[] dfa_48 = DFA.unpackEncodedStringToUnsignedChars(dfa_48s);
+ static final short[] dfa_49 = DFA.unpackEncodedString(dfa_49s);
+ static final short[] dfa_50 = DFA.unpackEncodedString(dfa_50s);
+ static final short[][] dfa_51 = unpackEncodedStringArray(dfa_51s);
+
+ class DFA62 extends DFA {
+
+ public DFA62(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 62;
+ this.eot = dfa_15;
+ this.eof = dfa_46;
+ this.min = dfa_47;
+ this.max = dfa_48;
+ this.accept = dfa_49;
+ this.special = dfa_50;
+ this.transition = dfa_51;
+ }
+ public String getDescription() {
+ return "()* loopback of 6149:2: ( rule__XOtherOperatorExpression__Group_1__0 )*";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA62_8 = input.LA(1);
+
+
+ int index62_8 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred106_InternalOXtype()) ) {s = 10;}
+
+ else if ( (true) ) {s = 1;}
+
+
+ input.seek(index62_8);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA62_6 = input.LA(1);
+
+
+ int index62_6 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred106_InternalOXtype()) ) {s = 10;}
+
+ else if ( (true) ) {s = 1;}
+
+
+ input.seek(index62_6);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA62_2 = input.LA(1);
+
+
+ int index62_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred106_InternalOXtype()) ) {s = 10;}
+
+ else if ( (true) ) {s = 1;}
+
+
+ input.seek(index62_2);
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA62_5 = input.LA(1);
+
+
+ int index62_5 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred106_InternalOXtype()) ) {s = 10;}
+
+ else if ( (true) ) {s = 1;}
+
+
+ input.seek(index62_5);
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA62_9 = input.LA(1);
+
+
+ int index62_9 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred106_InternalOXtype()) ) {s = 10;}
+
+ else if ( (true) ) {s = 1;}
+
+
+ input.seek(index62_9);
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA62_3 = input.LA(1);
+
+
+ int index62_3 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred106_InternalOXtype()) ) {s = 10;}
+
+ else if ( (true) ) {s = 1;}
+
+
+ input.seek(index62_3);
+ if ( s>=0 ) return s;
+ break;
+ case 6 :
+ int LA62_7 = input.LA(1);
+
+
+ int index62_7 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred106_InternalOXtype()) ) {s = 10;}
+
+ else if ( (true) ) {s = 1;}
+
+
+ input.seek(index62_7);
+ if ( s>=0 ) return s;
+ break;
+ case 7 :
+ int LA62_4 = input.LA(1);
+
+
+ int index62_4 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred106_InternalOXtype()) ) {s = 10;}
+
+ else if ( (true) ) {s = 1;}
+
+
+ input.seek(index62_4);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 62, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_52s = "\116\uffff";
+ static final String dfa_53s = "\1\2\115\uffff";
+ static final String dfa_54s = "\1\4\1\0\114\uffff";
+ static final String dfa_55s = "\1\130\1\0\114\uffff";
+ static final String dfa_56s = "\2\uffff\1\2\112\uffff\1\1";
+ static final String dfa_57s = "\1\uffff\1\0\114\uffff}>";
+ static final String[] dfa_58s = {
+ "\5\2\5\uffff\46\2\1\uffff\1\1\33\2\3\uffff\2\2\1\uffff\2\2",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] dfa_52 = DFA.unpackEncodedString(dfa_52s);
+ static final short[] dfa_53 = DFA.unpackEncodedString(dfa_53s);
+ static final char[] dfa_54 = DFA.unpackEncodedStringToUnsignedChars(dfa_54s);
+ static final char[] dfa_55 = DFA.unpackEncodedStringToUnsignedChars(dfa_55s);
+ static final short[] dfa_56 = DFA.unpackEncodedString(dfa_56s);
+ static final short[] dfa_57 = DFA.unpackEncodedString(dfa_57s);
+ static final short[][] dfa_58 = unpackEncodedStringArray(dfa_58s);
+
+ class DFA69 extends DFA {
+
+ public DFA69(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 69;
+ this.eot = dfa_52;
+ this.eof = dfa_53;
+ this.min = dfa_54;
+ this.max = dfa_55;
+ this.accept = dfa_56;
+ this.special = dfa_57;
+ this.transition = dfa_58;
+ }
+ public String getDescription() {
+ return "7743:2: ( rule__XMemberFeatureCall__Group_1_1_3__0 )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA69_1 = input.LA(1);
+
+
+ int index69_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred113_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index69_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 69, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String[] dfa_59s = {
+ "\5\2\5\uffff\46\2\1\uffff\5\2\1\1\26\2\3\uffff\2\2\1\uffff\2\2",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+ static final short[][] dfa_59 = unpackEncodedStringArray(dfa_59s);
+
+ class DFA70 extends DFA {
+
+ public DFA70(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 70;
+ this.eot = dfa_52;
+ this.eof = dfa_53;
+ this.min = dfa_54;
+ this.max = dfa_55;
+ this.accept = dfa_56;
+ this.special = dfa_57;
+ this.transition = dfa_59;
+ }
+ public String getDescription() {
+ return "7769:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA70_1 = input.LA(1);
+
+
+ int index70_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred114_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index70_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 70, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_60s = "\46\uffff";
+ static final String dfa_61s = "\1\4\2\0\43\uffff";
+ static final String dfa_62s = "\1\130\2\0\43\uffff";
+ static final String dfa_63s = "\3\uffff\1\1\1\uffff\1\2\40\uffff";
+ static final String dfa_64s = "\1\uffff\1\0\1\1\43\uffff}>";
+ static final String[] dfa_65s = {
+ "\1\1\4\5\22\uffff\1\5\3\uffff\1\3\2\uffff\2\5\4\uffff\1\5\3\uffff\7\5\2\uffff\1\2\2\uffff\3\5\2\uffff\1\5\1\uffff\1\5\1\uffff\1\5\3\uffff\11\5\1\uffff\1\5\6\uffff\1\3\2\5",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] dfa_60 = DFA.unpackEncodedString(dfa_60s);
+ static final char[] dfa_61 = DFA.unpackEncodedStringToUnsignedChars(dfa_61s);
+ static final char[] dfa_62 = DFA.unpackEncodedStringToUnsignedChars(dfa_62s);
+ static final short[] dfa_63 = DFA.unpackEncodedString(dfa_63s);
+ static final short[] dfa_64 = DFA.unpackEncodedString(dfa_64s);
+ static final short[][] dfa_65 = unpackEncodedStringArray(dfa_65s);
+
+ class DFA78 extends DFA {
+
+ public DFA78(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 78;
+ this.eot = dfa_60;
+ this.eof = dfa_60;
+ this.min = dfa_61;
+ this.max = dfa_62;
+ this.accept = dfa_63;
+ this.special = dfa_64;
+ this.transition = dfa_65;
+ }
+ public String getDescription() {
+ return "8742:2: ( rule__XClosure__Group_1__0 )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA78_1 = input.LA(1);
+
+
+ int index78_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred122_InternalOXtype()) ) {s = 3;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index78_1);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA78_2 = input.LA(1);
+
+
+ int index78_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred122_InternalOXtype()) ) {s = 3;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index78_2);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 78, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_66s = "\42\uffff";
+ static final String dfa_67s = "\1\4\2\0\37\uffff";
+ static final String dfa_68s = "\1\130\2\0\37\uffff";
+ static final String dfa_69s = "\3\uffff\1\1\1\2\35\uffff";
+ static final String dfa_70s = "\1\uffff\1\0\1\1\37\uffff}>";
+ static final String[] dfa_71s = {
+ "\1\1\4\4\22\uffff\1\4\3\uffff\1\3\2\uffff\2\4\4\uffff\1\4\4\uffff\6\4\2\uffff\1\2\3\uffff\2\4\2\uffff\1\4\1\uffff\1\4\1\uffff\1\4\3\uffff\11\4\1\uffff\1\4\10\uffff\1\4",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] dfa_66 = DFA.unpackEncodedString(dfa_66s);
+ static final char[] dfa_67 = DFA.unpackEncodedStringToUnsignedChars(dfa_67s);
+ static final char[] dfa_68 = DFA.unpackEncodedStringToUnsignedChars(dfa_68s);
+ static final short[] dfa_69 = DFA.unpackEncodedString(dfa_69s);
+ static final short[] dfa_70 = DFA.unpackEncodedString(dfa_70s);
+ static final short[][] dfa_71 = unpackEncodedStringArray(dfa_71s);
+
+ class DFA88 extends DFA {
+
+ public DFA88(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 88;
+ this.eot = dfa_66;
+ this.eof = dfa_66;
+ this.min = dfa_67;
+ this.max = dfa_68;
+ this.accept = dfa_69;
+ this.special = dfa_70;
+ this.transition = dfa_71;
+ }
+ public String getDescription() {
+ return "10173:2: ( rule__XSwitchExpression__Group_2_1_0__0 )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA88_1 = input.LA(1);
+
+
+ int index88_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred132_InternalOXtype()) ) {s = 3;}
+
+ else if ( (true) ) {s = 4;}
+
+
+ input.seek(index88_1);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA88_2 = input.LA(1);
+
+
+ int index88_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred132_InternalOXtype()) ) {s = 3;}
+
+ else if ( (true) ) {s = 4;}
+
+
+ input.seek(index88_2);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 88, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+ class DFA101 extends DFA {
+
+ public DFA101(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 101;
+ this.eot = dfa_52;
+ this.eof = dfa_53;
+ this.min = dfa_54;
+ this.max = dfa_55;
+ this.accept = dfa_56;
+ this.special = dfa_57;
+ this.transition = dfa_58;
+ }
+ public String getDescription() {
+ return "12306:2: ( rule__XFeatureCall__Group_3__0 )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA101_1 = input.LA(1);
+
+
+ int index101_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred145_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index101_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 101, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+ class DFA102 extends DFA {
+
+ public DFA102(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 102;
+ this.eot = dfa_52;
+ this.eof = dfa_53;
+ this.min = dfa_54;
+ this.max = dfa_55;
+ this.accept = dfa_56;
+ this.special = dfa_57;
+ this.transition = dfa_59;
+ }
+ public String getDescription() {
+ return "12332:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA102_1 = input.LA(1);
+
+
+ int index102_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred146_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index102_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 102, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String[] dfa_72s = {
+ "\5\2\5\uffff\15\2\1\1\30\2\1\uffff\34\2\3\uffff\2\2\1\uffff\2\2",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+ static final short[][] dfa_72 = unpackEncodedStringArray(dfa_72s);
+
+ class DFA106 extends DFA {
+
+ public DFA106(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 106;
+ this.eot = dfa_52;
+ this.eof = dfa_53;
+ this.min = dfa_54;
+ this.max = dfa_55;
+ this.accept = dfa_56;
+ this.special = dfa_57;
+ this.transition = dfa_72;
+ }
+ public String getDescription() {
+ return "12792:2: ( rule__XConstructorCall__Group_3__0 )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA106_1 = input.LA(1);
+
+
+ int index106_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred150_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index106_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 106, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+ class DFA107 extends DFA {
+
+ public DFA107(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 107;
+ this.eot = dfa_52;
+ this.eof = dfa_53;
+ this.min = dfa_54;
+ this.max = dfa_55;
+ this.accept = dfa_56;
+ this.special = dfa_57;
+ this.transition = dfa_58;
+ }
+ public String getDescription() {
+ return "12819:2: ( rule__XConstructorCall__Group_4__0 )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA107_1 = input.LA(1);
+
+
+ int index107_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred151_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index107_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 107, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+ class DFA108 extends DFA {
+
+ public DFA108(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 108;
+ this.eot = dfa_52;
+ this.eof = dfa_53;
+ this.min = dfa_54;
+ this.max = dfa_55;
+ this.accept = dfa_56;
+ this.special = dfa_57;
+ this.transition = dfa_59;
+ }
+ public String getDescription() {
+ return "12845:2: ( rule__XConstructorCall__ArgumentsAssignment_5 )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA108_1 = input.LA(1);
+
+
+ int index108_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred152_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index108_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 108, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_73s = "\1\41\115\uffff";
+ static final String dfa_74s = "\1\4\40\0\55\uffff";
+ static final String dfa_75s = "\1\130\40\0\55\uffff";
+ static final String dfa_76s = "\41\uffff\1\2\53\uffff\1\1";
+ static final String dfa_77s = "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35\1\36\1\37\55\uffff}>";
+ static final String[] dfa_78s = {
+ "\1\1\1\23\1\24\1\25\1\27\5\uffff\15\41\1\15\6\41\1\10\1\7\4\41\1\6\4\41\1\2\1\3\1\4\1\5\1\16\1\21\1\41\1\uffff\1\40\3\41\1\17\1\20\2\41\1\12\1\41\1\31\1\41\1\13\3\41\1\32\1\33\1\34\1\11\1\26\1\30\1\35\1\36\1\37\1\41\1\14\1\41\3\uffff\2\41\1\uffff\1\41\1\22",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+ static final short[] dfa_73 = DFA.unpackEncodedString(dfa_73s);
+ static final char[] dfa_74 = DFA.unpackEncodedStringToUnsignedChars(dfa_74s);
+ static final char[] dfa_75 = DFA.unpackEncodedStringToUnsignedChars(dfa_75s);
+ static final short[] dfa_76 = DFA.unpackEncodedString(dfa_76s);
+ static final short[] dfa_77 = DFA.unpackEncodedString(dfa_77s);
+ static final short[][] dfa_78 = unpackEncodedStringArray(dfa_78s);
+
+ class DFA113 extends DFA {
+
+ public DFA113(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 113;
+ this.eot = dfa_52;
+ this.eof = dfa_73;
+ this.min = dfa_74;
+ this.max = dfa_75;
+ this.accept = dfa_76;
+ this.special = dfa_77;
+ this.transition = dfa_78;
+ }
+ public String getDescription() {
+ return "13736:2: ( rule__XReturnExpression__ExpressionAssignment_2 )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA113_1 = input.LA(1);
+
+
+ int index113_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_1);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA113_2 = input.LA(1);
+
+
+ int index113_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_2);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA113_3 = input.LA(1);
+
+
+ int index113_3 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_3);
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA113_4 = input.LA(1);
+
+
+ int index113_4 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_4);
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA113_5 = input.LA(1);
+
+
+ int index113_5 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_5);
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA113_6 = input.LA(1);
+
+
+ int index113_6 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_6);
+ if ( s>=0 ) return s;
+ break;
+ case 6 :
+ int LA113_7 = input.LA(1);
+
+
+ int index113_7 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_7);
+ if ( s>=0 ) return s;
+ break;
+ case 7 :
+ int LA113_8 = input.LA(1);
+
+
+ int index113_8 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_8);
+ if ( s>=0 ) return s;
+ break;
+ case 8 :
+ int LA113_9 = input.LA(1);
+
+
+ int index113_9 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_9);
+ if ( s>=0 ) return s;
+ break;
+ case 9 :
+ int LA113_10 = input.LA(1);
+
+
+ int index113_10 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_10);
+ if ( s>=0 ) return s;
+ break;
+ case 10 :
+ int LA113_11 = input.LA(1);
+
+
+ int index113_11 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_11);
+ if ( s>=0 ) return s;
+ break;
+ case 11 :
+ int LA113_12 = input.LA(1);
+
+
+ int index113_12 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_12);
+ if ( s>=0 ) return s;
+ break;
+ case 12 :
+ int LA113_13 = input.LA(1);
+
+
+ int index113_13 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_13);
+ if ( s>=0 ) return s;
+ break;
+ case 13 :
+ int LA113_14 = input.LA(1);
+
+
+ int index113_14 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_14);
+ if ( s>=0 ) return s;
+ break;
+ case 14 :
+ int LA113_15 = input.LA(1);
+
+
+ int index113_15 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_15);
+ if ( s>=0 ) return s;
+ break;
+ case 15 :
+ int LA113_16 = input.LA(1);
+
+
+ int index113_16 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_16);
+ if ( s>=0 ) return s;
+ break;
+ case 16 :
+ int LA113_17 = input.LA(1);
+
+
+ int index113_17 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_17);
+ if ( s>=0 ) return s;
+ break;
+ case 17 :
+ int LA113_18 = input.LA(1);
+
+
+ int index113_18 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_18);
+ if ( s>=0 ) return s;
+ break;
+ case 18 :
+ int LA113_19 = input.LA(1);
+
+
+ int index113_19 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_19);
+ if ( s>=0 ) return s;
+ break;
+ case 19 :
+ int LA113_20 = input.LA(1);
+
+
+ int index113_20 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_20);
+ if ( s>=0 ) return s;
+ break;
+ case 20 :
+ int LA113_21 = input.LA(1);
+
+
+ int index113_21 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_21);
+ if ( s>=0 ) return s;
+ break;
+ case 21 :
+ int LA113_22 = input.LA(1);
+
+
+ int index113_22 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_22);
+ if ( s>=0 ) return s;
+ break;
+ case 22 :
+ int LA113_23 = input.LA(1);
+
+
+ int index113_23 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_23);
+ if ( s>=0 ) return s;
+ break;
+ case 23 :
+ int LA113_24 = input.LA(1);
+
+
+ int index113_24 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_24);
+ if ( s>=0 ) return s;
+ break;
+ case 24 :
+ int LA113_25 = input.LA(1);
+
+
+ int index113_25 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_25);
+ if ( s>=0 ) return s;
+ break;
+ case 25 :
+ int LA113_26 = input.LA(1);
+
+
+ int index113_26 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_26);
+ if ( s>=0 ) return s;
+ break;
+ case 26 :
+ int LA113_27 = input.LA(1);
+
+
+ int index113_27 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_27);
+ if ( s>=0 ) return s;
+ break;
+ case 27 :
+ int LA113_28 = input.LA(1);
+
+
+ int index113_28 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_28);
+ if ( s>=0 ) return s;
+ break;
+ case 28 :
+ int LA113_29 = input.LA(1);
+
+
+ int index113_29 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_29);
+ if ( s>=0 ) return s;
+ break;
+ case 29 :
+ int LA113_30 = input.LA(1);
+
+
+ int index113_30 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_30);
+ if ( s>=0 ) return s;
+ break;
+ case 30 :
+ int LA113_31 = input.LA(1);
+
+
+ int index113_31 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_31);
+ if ( s>=0 ) return s;
+ break;
+ case 31 :
+ int LA113_32 = input.LA(1);
+
+
+ int index113_32 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index113_32);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 113, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_79s = "\117\uffff";
+ static final String dfa_80s = "\1\2\116\uffff";
+ static final String dfa_81s = "\1\4\1\0\115\uffff";
+ static final String dfa_82s = "\1\130\1\0\115\uffff";
+ static final String dfa_83s = "\2\uffff\1\2\113\uffff\1\1";
+ static final String dfa_84s = "\1\uffff\1\0\115\uffff}>";
+ static final String[] dfa_85s = {
+ "\5\2\5\uffff\15\2\1\1\30\2\1\uffff\34\2\1\uffff\1\2\1\uffff\2\2\1\uffff\2\2",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] dfa_79 = DFA.unpackEncodedString(dfa_79s);
+ static final short[] dfa_80 = DFA.unpackEncodedString(dfa_80s);
+ static final char[] dfa_81 = DFA.unpackEncodedStringToUnsignedChars(dfa_81s);
+ static final char[] dfa_82 = DFA.unpackEncodedStringToUnsignedChars(dfa_82s);
+ static final short[] dfa_83 = DFA.unpackEncodedString(dfa_83s);
+ static final short[] dfa_84 = DFA.unpackEncodedString(dfa_84s);
+ static final short[][] dfa_85 = unpackEncodedStringArray(dfa_85s);
+
+ class DFA122 extends DFA {
+
+ public DFA122(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 122;
+ this.eot = dfa_79;
+ this.eof = dfa_80;
+ this.min = dfa_81;
+ this.max = dfa_82;
+ this.accept = dfa_83;
+ this.special = dfa_84;
+ this.transition = dfa_85;
+ }
+ public String getDescription() {
+ return "15093:2: ( rule__JvmParameterizedTypeReference__Group_1__0 )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA122_1 = input.LA(1);
+
+
+ int index122_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred166_InternalOXtype()) ) {s = 78;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index122_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 122, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+ class DFA125 extends DFA {
+
+ public DFA125(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 125;
+ this.eot = dfa_79;
+ this.eof = dfa_80;
+ this.min = dfa_81;
+ this.max = dfa_82;
+ this.accept = dfa_83;
+ this.special = dfa_84;
+ this.transition = dfa_85;
+ }
+ public String getDescription() {
+ return "15363:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA125_1 = input.LA(1);
+
+
+ int index125_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred169_InternalOXtype()) ) {s = 78;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index125_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 125, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+
+ public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000012L});
+ public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000400000000010L,0x0000000000080000L});
+ public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0008000000000000L});
+ public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0001000000000010L});
+ public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000001000000010L});
+ public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000000010L});
+ public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0010000000000000L});
+ public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0020000000000000L});
+ public static final BitSet FOLLOW_12 = new BitSet(new long[]{0xA677E10C080001F0L,0x000000000100BFE2L});
+ public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0080000000000000L});
+ public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0080000000000002L});
+ public static final BitSet FOLLOW_15 = new BitSet(new long[]{0xA637E10C080001F0L,0x000000000100BFE2L});
+ public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000002000L});
+ public static final BitSet FOLLOW_17 = new BitSet(new long[]{0xA737E10C080001F0L,0x000000000100BFE2L});
+ public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0200000000000000L});
+ public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0400000000000000L});
+ public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0001E00000000010L});
+ public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x000000000C1F0000L});
+ public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000008000000L});
+ public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000006000000L});
+ public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000000004000L});
+ public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000000004002L});
+ public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000008000L});
+ public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000008002L});
+ public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000001E00000L});
+ public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000001E00002L});
+ public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x080000000E000000L});
+ public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x080000000E000002L});
+ public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0020000080000010L});
+ public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0800000000000000L});
+ public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x00000003FC000000L});
+ public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x00000003FC000002L});
+ public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000004000000L});
+ public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000088000000L});
+ public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000C00000000L});
+ public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000C00000002L});
+ public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x000000F000000000L});
+ public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x000000F000000002L});
+ public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000010C00000000L});
+ public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x1000000000000000L});
+ public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x1000000000000002L});
+ public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000060000000000L});
+ public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000080000000000L,0x0000000000300000L});
+ public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000080000000002L,0x0000000000300000L});
+ public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000080000000000L,0x0000000000100000L});
+ public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0003E00008000010L});
+ public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0420000000000000L});
+ public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0020000080000010L,0x0000000000020000L});
+ public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0080000004000000L});
+ public static final BitSet FOLLOW_54 = new BitSet(new long[]{0xA677E10C880001F0L,0x000000000140BFE2L});
+ public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x2000000000000000L});
+ public static final BitSet FOLLOW_56 = new BitSet(new long[]{0xE637E10C080001F0L,0x000000000100BFE2L});
+ public static final BitSet FOLLOW_57 = new BitSet(new long[]{0xA637F10C880001F0L,0x0000000001C0BFE2L});
+ public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0100000000000000L});
+ public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0020000080000010L,0x0000000000400000L});
+ public static final BitSet FOLLOW_60 = new BitSet(new long[]{0xA637F10C080001F2L,0x000000000180BFE2L});
+ public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0040000000000000L});
+ public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x8000000000000000L});
+ public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L});
+ public static final BitSet FOLLOW_65 = new BitSet(new long[]{0xA637E10C880001F0L,0x000000000100BFE2L});
+ public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x40A0000080000010L,0x000000000000001CL});
+ public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x00A0000080000012L,0x0000000000000014L});
+ public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
+ public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x00A0000080000010L,0x0000000000000014L});
+ public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});
+ public static final BitSet FOLLOW_71 = new BitSet(new long[]{0xA63FF10C080001F0L,0x000000000180BFE2L});
+ public static final BitSet FOLLOW_72 = new BitSet(new long[]{0xA63FE10C080001F0L,0x000000000100BFE2L});
+ public static final BitSet FOLLOW_73 = new BitSet(new long[]{0xA637F10C080001F0L,0x000000000180BFE2L});
+ public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
+ public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
+ public static final BitSet FOLLOW_76 = new BitSet(new long[]{0xE637F10C080001F0L,0x000000000180BFE2L});
+ public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0000100000000000L,0x0000000000800000L});
+ public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
+ public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0420000008000000L});
+ public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x0004000000000000L,0x0000000001000000L});
+ public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L});
+ public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x00000000000000E0L});
+ public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000000000000100L});
+ public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x06040000000001E0L,0x0000000001000600L});
+ public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0440000000000000L});
+ public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0400000000000002L});
+ public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
+ public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L});
+ public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
+ public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0000000000000000L,0x0000000000014000L});
+ public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
+ public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x0000000000000002L,0x0000000000010000L});
+ public static final BitSet FOLLOW_93 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
+ public static final BitSet FOLLOW_94 = new BitSet(new long[]{0x0000080000000000L});
+ public static final BitSet FOLLOW_95 = new BitSet(new long[]{0x0000080000000002L});
+ public static final BitSet FOLLOW_96 = new BitSet(new long[]{0x00000000000000C0L});
+ public static final BitSet FOLLOW_97 = new BitSet(new long[]{0x0060000080000010L});
+ public static final BitSet FOLLOW_98 = new BitSet(new long[]{0x0002200000000000L});
+ public static final BitSet FOLLOW_99 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
+ public static final BitSet FOLLOW_100 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
+ public static final BitSet FOLLOW_101 = new BitSet(new long[]{0x0000001000000000L});
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src/org/eclipse/osbp/xtext/oxtype/ide/OXtypeIdeModule.xtend b/org.eclipse.osbp.xtext.oxtype.ide/src/org/eclipse/osbp/xtext/oxtype/ide/OXtypeIdeModule.xtend
new file mode 100644
index 0000000..27096f7
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src/org/eclipse/osbp/xtext/oxtype/ide/OXtypeIdeModule.xtend
@@ -0,0 +1,11 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ide
+
+
+/**
+ * Use this class to register ide components.
+ */
+class OXtypeIdeModule extends AbstractOXtypeIdeModule {
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src/org/eclipse/osbp/xtext/oxtype/ide/OXtypeIdeSetup.xtend b/org.eclipse.osbp.xtext.oxtype.ide/src/org/eclipse/osbp/xtext/oxtype/ide/OXtypeIdeSetup.xtend
new file mode 100644
index 0000000..d33817c
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src/org/eclipse/osbp/xtext/oxtype/ide/OXtypeIdeSetup.xtend
@@ -0,0 +1,20 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ide
+
+import com.google.inject.Guice
+import org.eclipse.osbp.xtext.oxtype.OXtypeRuntimeModule
+import org.eclipse.osbp.xtext.oxtype.OXtypeStandaloneSetup
+import org.eclipse.xtext.util.Modules2
+
+/**
+ * Initialization support for running Xtext languages as language servers.
+ */
+class OXtypeIdeSetup extends OXtypeStandaloneSetup {
+
+ override createInjector() {
+ Guice.createInjector(Modules2.mixin(new OXtypeRuntimeModule, new OXtypeIdeModule))
+ }
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.tests/.project b/org.eclipse.osbp.xtext.oxtype.tests/.project
new file mode 100644
index 0000000..d1837d0
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.tests/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>org.eclipse.osbp.xtext.oxtype.tests</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.m2e.core.maven2Builder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <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.m2e.core.maven2Nature</nature>
+ <nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ <nature>org.eclipse.pde.PluginNature</nature>
+ </natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.xtext.oxtype.tests/META-INF/MANIFEST.MF b/org.eclipse.osbp.xtext.oxtype.tests/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..e37f93a
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.tests/META-INF/MANIFEST.MF
@@ -0,0 +1,22 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.osbp.xtext.oxtype.tests
+Bundle-Vendor: Eclipse OSBP
+Bundle-Version: 0.9.0.qualifier
+Bundle-SymbolicName: org.eclipse.osbp.xtext.oxtype.tests; singleton:=true
+Bundle-ActivationPolicy: lazy
+Require-Bundle: org.eclipse.osbp.xtext.oxtype,
+ org.junit;bundle-version="4.7.0",
+ org.eclipse.xtext.testing,
+ org.eclipse.xtext.xbase.junit,
+ org.eclipse.xtext.xbase.lib,
+ org.objectweb.asm;bundle-version="[5.0.1,6.0.0)";resolution:=optional
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Export-Package: org.eclipse.osbp.xtext.oxtype.tests;x-internal=true
+Import-Package: org.hamcrest.core,
+ org.junit;version="4.5.0",
+ org.junit.runners.model;version="4.5.0",
+ org.junit.runner;version="4.5.0",
+ org.junit.runners;version="4.5.0",
+ org.junit.runner.manipulation;version="4.5.0",
+ org.junit.runner.notification;version="4.5.0"
diff --git a/org.eclipse.osbp.xtext.oxtype.tests/build.properties b/org.eclipse.osbp.xtext.oxtype.tests/build.properties
new file mode 100644
index 0000000..5c6bbf9
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.tests/build.properties
@@ -0,0 +1,6 @@
+source.. = src/,\
+ src-gen/,\
+ xtend-gen/
+bin.includes = .,\
+ META-INF/
+bin.excludes = **/*.xtend
diff --git a/org.eclipse.osbp.xtext.oxtype.tests/pom.xml b/org.eclipse.osbp.xtext.oxtype.tests/pom.xml
new file mode 100644
index 0000000..cc37357
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.tests/pom.xml
@@ -0,0 +1,30 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.eclipse.osbp.xtext.oxtype</groupId>
+ <artifactId>org.eclipse.osbp.xtext.oxtype.aggregator</artifactId>
+ <version>0.9.0-SNAPSHOT</version>
+ <relativePath>..</relativePath>
+ </parent>
+ <artifactId>org.eclipse.osbp.xtext.oxtype.tests</artifactId>
+ <packaging>eclipse-test-plugin</packaging>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.eclipse.xtend</groupId>
+ <artifactId>xtend-maven-plugin</artifactId>
+ </plugin>
+ <plugin>
+ <groupId>org.eclipse.tycho</groupId>
+ <artifactId>tycho-surefire-plugin</artifactId>
+ <version>${tycho-version}</version>
+ <configuration>
+ <failIfNoTests>false</failIfNoTests>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+
+</project>
diff --git a/org.eclipse.osbp.xtext.oxtype.tests/src-gen/org/eclipse/osbp/xtext/oxtype/tests/OXtypeInjectorProvider.java b/org.eclipse.osbp.xtext.oxtype.tests/src-gen/org/eclipse/osbp/xtext/oxtype/tests/OXtypeInjectorProvider.java
new file mode 100644
index 0000000..4a4ed2d
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.tests/src-gen/org/eclipse/osbp/xtext/oxtype/tests/OXtypeInjectorProvider.java
@@ -0,0 +1,66 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.tests;
+
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import org.eclipse.osbp.xtext.oxtype.OXtypeRuntimeModule;
+import org.eclipse.osbp.xtext.oxtype.OXtypeStandaloneSetup;
+import org.eclipse.xtext.testing.GlobalRegistries;
+import org.eclipse.xtext.testing.GlobalRegistries.GlobalStateMemento;
+import org.eclipse.xtext.testing.IInjectorProvider;
+import org.eclipse.xtext.testing.IRegistryConfigurator;
+
+public class OXtypeInjectorProvider implements IInjectorProvider, IRegistryConfigurator {
+
+ protected GlobalStateMemento stateBeforeInjectorCreation;
+ protected GlobalStateMemento stateAfterInjectorCreation;
+ protected Injector injector;
+
+ static {
+ GlobalRegistries.initializeDefaults();
+ }
+
+ @Override
+ public Injector getInjector() {
+ if (injector == null) {
+ stateBeforeInjectorCreation = GlobalRegistries.makeCopyOfGlobalState();
+ this.injector = internalCreateInjector();
+ stateAfterInjectorCreation = GlobalRegistries.makeCopyOfGlobalState();
+ }
+ return injector;
+ }
+
+ protected Injector internalCreateInjector() {
+ return new OXtypeStandaloneSetup() {
+ @Override
+ public Injector createInjector() {
+ return Guice.createInjector(createRuntimeModule());
+ }
+ }.createInjectorAndDoEMFRegistration();
+ }
+
+ protected OXtypeRuntimeModule createRuntimeModule() {
+ // make it work also with Maven/Tycho and OSGI
+ // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=493672
+ return new OXtypeRuntimeModule() {
+ @Override
+ public ClassLoader bindClassLoaderToInstance() {
+ return OXtypeInjectorProvider.class
+ .getClassLoader();
+ }
+ };
+ }
+
+ @Override
+ public void restoreRegistry() {
+ stateBeforeInjectorCreation.restoreGlobalState();
+ }
+
+ @Override
+ public void setupRegistry() {
+ getInjector();
+ stateAfterInjectorCreation.restoreGlobalState();
+ }
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.tests/src/org/eclipse/osbp/xtext/oxtype/tests/OXtypeParsingTest.xtend b/org.eclipse.osbp.xtext.oxtype.tests/src/org/eclipse/osbp/xtext/oxtype/tests/OXtypeParsingTest.xtend
new file mode 100644
index 0000000..aae0f44
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.tests/src/org/eclipse/osbp/xtext/oxtype/tests/OXtypeParsingTest.xtend
@@ -0,0 +1,29 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.tests
+
+import com.google.inject.Inject
+import org.eclipse.xtext.testing.InjectWith
+import org.eclipse.xtext.testing.XtextRunner
+import org.eclipse.xtext.testing.util.ParseHelper
+import org.junit.Assert
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration
+
+@RunWith(XtextRunner)
+@InjectWith(OXtypeInjectorProvider)
+class OXtypeParsingTest {
+ @Inject
+ ParseHelper<OXImportDeclaration> parseHelper
+
+ @Test
+ def void loadModel() {
+ val result = parseHelper.parse('''
+ Hello Xtext!
+ ''')
+ Assert.assertNotNull(result)
+ Assert.assertTrue(result.eResource.errors.isEmpty)
+ }
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui.tests/.project b/org.eclipse.osbp.xtext.oxtype.ui.tests/.project
new file mode 100644
index 0000000..584b481
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui.tests/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>org.eclipse.osbp.xtext.oxtype.ui.tests</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.m2e.core.maven2Builder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <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.m2e.core.maven2Nature</nature>
+ <nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ <nature>org.eclipse.pde.PluginNature</nature>
+ </natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.xtext.oxtype.ui.tests/META-INF/MANIFEST.MF b/org.eclipse.osbp.xtext.oxtype.ui.tests/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..57062ae
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui.tests/META-INF/MANIFEST.MF
@@ -0,0 +1,22 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.osbp.xtext.oxtype.ui.tests
+Bundle-Vendor: Eclipse OSBP
+Bundle-Version: 0.9.0.qualifier
+Bundle-SymbolicName: org.eclipse.osbp.xtext.oxtype.ui.tests; singleton:=true
+Bundle-ActivationPolicy: lazy
+Require-Bundle: org.eclipse.osbp.xtext.oxtype.ui,
+ org.junit;bundle-version="4.7.0",
+ org.eclipse.xtext.testing,
+ org.eclipse.xtext.xbase.junit,
+ org.eclipse.core.runtime,
+ org.eclipse.ui.workbench;resolution:=optional
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Export-Package: org.eclipse.osbp.xtext.oxtype.ui.tests;x-internal=true
+Import-Package: org.hamcrest.core,
+ org.junit;version="4.5.0",
+ org.junit.runners.model;version="4.5.0",
+ org.junit.runner;version="4.5.0",
+ org.junit.runners;version="4.5.0",
+ org.junit.runner.manipulation;version="4.5.0",
+ org.junit.runner.notification;version="4.5.0"
diff --git a/org.eclipse.osbp.xtext.oxtype.ui.tests/build.properties b/org.eclipse.osbp.xtext.oxtype.ui.tests/build.properties
new file mode 100644
index 0000000..5c6bbf9
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui.tests/build.properties
@@ -0,0 +1,6 @@
+source.. = src/,\
+ src-gen/,\
+ xtend-gen/
+bin.includes = .,\
+ META-INF/
+bin.excludes = **/*.xtend
diff --git a/org.eclipse.osbp.xtext.oxtype.ui.tests/pom.xml b/org.eclipse.osbp.xtext.oxtype.ui.tests/pom.xml
new file mode 100644
index 0000000..62f29eb
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui.tests/pom.xml
@@ -0,0 +1,63 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.eclipse.osbp.xtext.oxtype</groupId>
+ <artifactId>org.eclipse.osbp.xtext.oxtype.aggregator</artifactId>
+ <version>0.9.0-SNAPSHOT</version>
+ <relativePath>..</relativePath>
+ </parent>
+ <artifactId>org.eclipse.osbp.xtext.oxtype.ui.tests</artifactId>
+ <packaging>eclipse-test-plugin</packaging>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.eclipse.xtend</groupId>
+ <artifactId>xtend-maven-plugin</artifactId>
+ </plugin>
+ <plugin>
+ <groupId>org.eclipse.tycho</groupId>
+ <artifactId>tycho-surefire-plugin</artifactId>
+ <version>${tycho-version}</version>
+ <configuration>
+ <failIfNoTests>false</failIfNoTests>
+ <useUIHarness>true</useUIHarness>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.eclipse.tycho</groupId>
+ <artifactId>target-platform-configuration</artifactId>
+ <configuration>
+ <dependency-resolution>
+ <extraRequirements>
+ <!-- to get the org.eclipse.osgi.compatibility.state plugin
+ if the target platform is Luna or later.
+ (backward compatible with kepler and previous versions)
+ see https://bugs.eclipse.org/bugs/show_bug.cgi?id=492149 -->
+ <requirement>
+ <type>eclipse-feature</type>
+ <id>org.eclipse.rcp</id>
+ <versionRange>0.0.0</versionRange>
+ </requirement>
+ </extraRequirements>
+ </dependency-resolution>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+
+ <profiles>
+ <profile>
+ <id>testing-on-mac</id>
+ <activation>
+ <os>
+ <family>mac</family>
+ </os>
+ </activation>
+ <properties>
+ <tycho.testArgLine>-XstartOnFirstThread</tycho.testArgLine>
+ </properties>
+ </profile>
+ </profiles>
+</project>
diff --git a/org.eclipse.osbp.xtext.oxtype.ui.tests/src-gen/org/eclipse/osbp/xtext/oxtype/ui/tests/OXtypeUiInjectorProvider.java b/org.eclipse.osbp.xtext.oxtype.ui.tests/src-gen/org/eclipse/osbp/xtext/oxtype/ui/tests/OXtypeUiInjectorProvider.java
new file mode 100644
index 0000000..1604aa9
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui.tests/src-gen/org/eclipse/osbp/xtext/oxtype/ui/tests/OXtypeUiInjectorProvider.java
@@ -0,0 +1,17 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui.tests;
+
+import com.google.inject.Injector;
+import org.eclipse.osbp.xtext.oxtype.ui.internal.OxtypeActivator;
+import org.eclipse.xtext.testing.IInjectorProvider;
+
+public class OXtypeUiInjectorProvider implements IInjectorProvider {
+
+ @Override
+ public Injector getInjector() {
+ return OxtypeActivator.getInstance().getInjector("org.eclipse.osbp.xtext.oxtype.OXtype");
+ }
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/.project b/org.eclipse.osbp.xtext.oxtype.ui/.project
new file mode 100644
index 0000000..152539f
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>org.eclipse.osbp.xtext.oxtype.ui</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.m2e.core.maven2Builder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <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.m2e.core.maven2Nature</nature>
+ <nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ <nature>org.eclipse.pde.PluginNature</nature>
+ </natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/META-INF/MANIFEST.MF b/org.eclipse.osbp.xtext.oxtype.ui/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..15e4773
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/META-INF/MANIFEST.MF
@@ -0,0 +1,28 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.osbp.xtext.oxtype.ui
+Bundle-Vendor: Eclipse OSBP
+Bundle-Version: 0.9.0.qualifier
+Bundle-SymbolicName: org.eclipse.osbp.xtext.oxtype.ui; singleton:=true
+Bundle-ActivationPolicy: lazy
+Require-Bundle: org.eclipse.xtext.ui,
+ org.eclipse.xtext.ui.shared,
+ org.eclipse.xtext.ui.codetemplates.ui,
+ org.eclipse.ui.editors;bundle-version="3.5.0",
+ org.eclipse.ui.ide;bundle-version="3.5.0",
+ org.eclipse.xtext.xbase.lib,
+ org.eclipse.xtext.common.types.ui,
+ org.eclipse.xtend.lib;resolution:=optional,
+ org.eclipse.ui,
+ org.eclipse.xtext.xbase.ui,
+ org.eclipse.compare,
+ org.eclipse.xtext.builder,
+ org.eclipse.jdt.debug.ui,
+ org.eclipse.osbp.xtext.oxtype,
+ org.eclipse.osbp.xtext.oxtype.ide
+Import-Package: org.apache.log4j
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Export-Package: org.eclipse.osbp.xtext.oxtype.ui.internal,
+ org.eclipse.osbp.xtext.oxtype.ui.quickfix,
+ org.eclipse.osbp.xtext.oxtype.ui.contentassist
+Bundle-Activator: org.eclipse.osbp.xtext.oxtype.ui.internal.OxtypeActivator
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/build.properties b/org.eclipse.osbp.xtext.oxtype.ui/build.properties
new file mode 100644
index 0000000..323f56c
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/build.properties
@@ -0,0 +1,7 @@
+source.. = src/,\
+ src-gen/,\
+ xtend-gen/
+bin.includes = .,\
+ META-INF/,\
+ plugin.xml
+bin.excludes = **/*.xtend
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/plugin.xml b/org.eclipse.osbp.xtext.oxtype.ui/plugin.xml
new file mode 100644
index 0000000..00a296d
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/plugin.xml
@@ -0,0 +1,569 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+<plugin>
+ <extension
+ point="org.eclipse.ui.editors">
+ <editor
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.XtextEditor"
+ contributorClass="org.eclipse.ui.editors.text.TextEditorActionContributor"
+ default="true"
+ extensions="oxtype"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype"
+ matchingStrategy="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.editor.JavaEditorInputMatcher"
+ name="OXtype Editor">
+ </editor>
+ </extension>
+ <extension
+ point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclarationHandler"
+ commandId="org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclaration">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.handler.ValidateActionHandler"
+ commandId="org.eclipse.osbp.xtext.oxtype.OXtype.validate">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ <!-- copy qualified name -->
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedNameHandler"
+ commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName">
+ <activeWhen>
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+ </activeWhen>
+ </handler>
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedNameHandler"
+ commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedName">
+ <activeWhen>
+ <and>
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.XtextEditor.opened" />
+ <iterate>
+ <adapt type="org.eclipse.xtext.ui.editor.outline.IOutlineNode" />
+ </iterate>
+ </and>
+ </activeWhen>
+ </handler>
+ </extension>
+ <extension point="org.eclipse.core.expressions.definitions">
+ <definition id="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ <and>
+ <reference definitionId="isActiveEditorAnInstanceOfXtextEditor"/>
+ <with variable="activeEditor">
+ <test property="org.eclipse.xtext.ui.editor.XtextEditor.languageName"
+ value="org.eclipse.osbp.xtext.oxtype.OXtype"
+ forcePluginActivation="true"/>
+ </with>
+ </and>
+ </definition>
+ <definition id="org.eclipse.osbp.xtext.oxtype.OXtype.XtextEditor.opened">
+ <and>
+ <reference definitionId="isXtextEditorActive"/>
+ <with variable="activeEditor">
+ <test property="org.eclipse.xtext.ui.editor.XtextEditor.languageName"
+ value="org.eclipse.osbp.xtext.oxtype.OXtype"
+ forcePluginActivation="true"/>
+ </with>
+ </and>
+ </definition>
+ </extension>
+ <extension
+ point="org.eclipse.ui.preferencePages">
+ <page
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.preferences.LanguageRootPreferencePage"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype"
+ name="OXtype">
+ <keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+ </page>
+ <page
+ category="org.eclipse.osbp.xtext.oxtype.OXtype"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.syntaxcoloring.SyntaxColoringPreferencePage"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.coloring"
+ name="Syntax Coloring">
+ <keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+ </page>
+ <page
+ category="org.eclipse.osbp.xtext.oxtype.OXtype"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.templates.XtextTemplatePreferencePage"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.templates"
+ name="Templates">
+ <keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+ </page>
+ </extension>
+ <extension
+ point="org.eclipse.ui.propertyPages">
+ <page
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.preferences.LanguageRootPreferencePage"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype"
+ name="OXtype">
+ <keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+ <enabledWhen>
+ <adapt type="org.eclipse.core.resources.IProject"/>
+ </enabledWhen>
+ <filter name="projectNature" value="org.eclipse.xtext.ui.shared.xtextNature"/>
+ </page>
+ </extension>
+ <extension
+ point="org.eclipse.ui.keywords">
+ <keyword
+ id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"
+ label="OXtype"/>
+ </extension>
+ <extension
+ point="org.eclipse.ui.commands">
+ <command
+ description="Trigger expensive validation"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.validate"
+ name="Validate">
+ </command>
+ <!-- copy qualified name -->
+ <command
+ id="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName"
+ categoryId="org.eclipse.ui.category.edit"
+ description="Copy the qualified name for the selected element"
+ name="Copy Qualified Name">
+ </command>
+ <command
+ id="org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedName"
+ categoryId="org.eclipse.ui.category.edit"
+ description="Copy the qualified name for the selected element"
+ name="Copy Qualified Name">
+ </command>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution
+ locationURI="popup:#TextEditorContext?after=group.edit">
+ <command
+ commandId="org.eclipse.osbp.xtext.oxtype.OXtype.validate"
+ style="push"
+ tooltip="Trigger expensive validation">
+ <visibleWhen checkEnabled="false">
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ <!-- copy qualified name -->
+ <menuContribution locationURI="popup:#TextEditorContext?after=copy">
+ <command commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName"
+ style="push" tooltip="Copy Qualified Name">
+ <visibleWhen checkEnabled="false">
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ <menuContribution locationURI="menu:edit?after=copy">
+ <command commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName"
+ style="push" tooltip="Copy Qualified Name">
+ <visibleWhen checkEnabled="false">
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ <menuContribution locationURI="popup:org.eclipse.xtext.ui.outline?after=additions">
+ <command commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedName"
+ style="push" tooltip="Copy Qualified Name">
+ <visibleWhen checkEnabled="false">
+ <and>
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.XtextEditor.opened" />
+ <iterate>
+ <adapt type="org.eclipse.xtext.ui.editor.outline.IOutlineNode" />
+ </iterate>
+ </and>
+ </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.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <extension point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.findrefs.FindReferencesHandler"
+ commandId="org.eclipse.xtext.ui.editor.FindReferences">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+ <!-- adding resource factories -->
+ <extension
+ point="org.eclipse.emf.ecore.extension_parser">
+ <parser
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.resource.IResourceFactory"
+ type="oxtype">
+ </parser>
+ </extension>
+ <extension point="org.eclipse.xtext.extension_resourceServiceProvider">
+ <resourceServiceProvider
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.resource.IResourceUIServiceProvider"
+ uriExtension="oxtype">
+ </resourceServiceProvider>
+ </extension>
+ <!-- marker definitions for org.eclipse.osbp.xtext.oxtype.OXtype -->
+ <extension
+ id="oxtype.check.fast"
+ name="OXtype Problem"
+ point="org.eclipse.core.resources.markers">
+ <super type="org.eclipse.xtext.ui.check.fast"/>
+ <persistent value="true"/>
+ </extension>
+ <extension
+ id="oxtype.check.normal"
+ name="OXtype Problem"
+ point="org.eclipse.core.resources.markers">
+ <super type="org.eclipse.xtext.ui.check.normal"/>
+ <persistent value="true"/>
+ </extension>
+ <extension
+ id="oxtype.check.expensive"
+ name="OXtype Problem"
+ point="org.eclipse.core.resources.markers">
+ <super type="org.eclipse.xtext.ui.check.expensive"/>
+ <persistent value="true"/>
+ </extension>
+ <extension point="org.eclipse.xtext.builder.participant">
+ <participant
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.builder.IXtextBuilderParticipant"
+ fileExtensions="oxtype"/>
+ </extension>
+ <extension point="org.eclipse.ui.preferencePages">
+ <page
+ category="org.eclipse.osbp.xtext.oxtype.OXtype"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.builder.preferences.BuilderPreferencePage"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.compiler.preferencePage"
+ name="Compiler">
+ <keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+ </page>
+ </extension>
+ <extension point="org.eclipse.ui.propertyPages">
+ <page
+ category="org.eclipse.osbp.xtext.oxtype.OXtype"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.builder.preferences.BuilderPreferencePage"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.compiler.propertyPage"
+ name="Compiler">
+ <keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+ <enabledWhen>
+ <adapt type="org.eclipse.core.resources.IProject"/>
+ </enabledWhen>
+ <filter name="projectNature" value="org.eclipse.xtext.ui.shared.xtextNature"/>
+ </page>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution locationURI="popup:#TextEditorContext?after=xtext.ui.openDeclaration">
+ <command
+ commandId="org.eclipse.xtext.ui.OpenGeneratedFileCommand"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.OpenGeneratedCode"
+ style="push">
+ <visibleWhen checkEnabled="false">
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <extension point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.generator.trace.OpenGeneratedFileHandler"
+ commandId="org.eclipse.xtext.ui.OpenGeneratedFileCommand">
+ <activeWhen>
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+ </activeWhen>
+ </handler>
+ </extension>
+ <!-- Quick Outline -->
+ <extension
+ point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.outline.quickoutline.ShowQuickOutlineActionHandler"
+ commandId="org.eclipse.xtext.ui.editor.outline.QuickOutline">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.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.osbp.xtext.oxtype.OXtype.Editor.opened"/>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <!-- quickfix marker resolution generator for org.eclipse.osbp.xtext.oxtype.OXtype -->
+ <extension
+ point="org.eclipse.ui.ide.markerResolution">
+ <markerResolutionGenerator
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator"
+ markerType="org.eclipse.osbp.xtext.oxtype.ui.oxtype.check.fast">
+ <attribute
+ name="FIXABLE_KEY"
+ value="true">
+ </attribute>
+ </markerResolutionGenerator>
+ <markerResolutionGenerator
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator"
+ markerType="org.eclipse.osbp.xtext.oxtype.ui.oxtype.check.normal">
+ <attribute
+ name="FIXABLE_KEY"
+ value="true">
+ </attribute>
+ </markerResolutionGenerator>
+ <markerResolutionGenerator
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator"
+ markerType="org.eclipse.osbp.xtext.oxtype.ui.oxtype.check.expensive">
+ <attribute
+ name="FIXABLE_KEY"
+ value="true">
+ </attribute>
+ </markerResolutionGenerator>
+ </extension>
+ <!-- Rename Refactoring -->
+ <extension point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.refactoring.ui.DefaultRenameElementHandler"
+ commandId="org.eclipse.xtext.ui.refactoring.RenameElement">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution
+ locationURI="popup:#TextEditorContext?after=group.edit">
+ <command commandId="org.eclipse.xtext.ui.refactoring.RenameElement"
+ style="push">
+ <visibleWhen checkEnabled="false">
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <extension point="org.eclipse.ui.preferencePages">
+ <page
+ category="org.eclipse.osbp.xtext.oxtype.OXtype"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.refactoring.ui.RefactoringPreferencePage"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.refactoring"
+ name="Refactoring">
+ <keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+ </page>
+ </extension>
+ <!-- Type Hierarchy -->
+ <extension point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.hierarchy.OpenTypeHierarchyHandler"
+ commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenTypeHierarchy">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.hierarchy.QuickTypeHierarchyHandler"
+ commandId="org.eclipse.jdt.ui.edit.text.java.open.hierarchy">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution
+ locationURI="popup:#TextEditorContext?after=group.open">
+ <command commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenTypeHierarchy"
+ style="push"
+ tooltip="Open Type Hierarchy">
+ <visibleWhen checkEnabled="false">
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened"/>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ <menuContribution
+ locationURI="popup:#TextEditorContext?after=group.open">
+ <command commandId="org.eclipse.jdt.ui.edit.text.java.open.hierarchy"
+ style="push"
+ tooltip="Quick Type Hierarchy">
+ <visibleWhen checkEnabled="false">
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened"/>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <!-- Call Hierachy -->
+ <extension point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.hierarchy.OpenCallHierachyHandler"
+ commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenCallHierarchy">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution
+ locationURI="popup:#TextEditorContext?after=group.open">
+ <command commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenCallHierarchy"
+ style="push"
+ tooltip="Open Call Hierarchy">
+ <visibleWhen checkEnabled="false">
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened"/>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <extension point="org.eclipse.core.runtime.adapters">
+ <factory class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.builder.smap.StratumBreakpointAdapterFactory"
+ adaptableType="org.eclipse.xtext.ui.editor.XtextEditor">
+ <adapter type="org.eclipse.debug.ui.actions.IToggleBreakpointsTarget"/>
+ </factory>
+ </extension>
+ <extension point="org.eclipse.ui.editorActions">
+ <editorContribution targetID="org.eclipse.osbp.xtext.oxtype.OXtype"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.rulerActions">
+ <action
+ label="Not Used"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.debug.ui.actions.RulerToggleBreakpointActionDelegate"
+ style="push"
+ actionID="RulerDoubleClick"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.doubleClickBreakpointAction"/>
+ </editorContribution>
+ </extension>
+ <extension point="org.eclipse.ui.popupMenus">
+ <viewerContribution
+ targetID="org.eclipse.osbp.xtext.oxtype.OXtype.RulerContext"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.RulerPopupActions">
+ <action
+ label="Toggle Breakpoint"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.debug.ui.actions.RulerToggleBreakpointActionDelegate"
+ menubarPath="debug"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.rulerContextMenu.toggleBreakpointAction">
+ </action>
+ <action
+ label="Not used"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.debug.ui.actions.RulerEnableDisableBreakpointActionDelegate"
+ menubarPath="debug"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.rulerContextMenu.enableDisableBreakpointAction">
+ </action>
+ <action
+ label="Breakpoint Properties"
+ helpContextId="breakpoint_properties_action_context"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.jdt.debug.ui.actions.JavaBreakpointPropertiesRulerActionDelegate"
+ menubarPath="group.properties"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.rulerContextMenu.openBreapointPropertiesAction">
+ </action>
+ </viewerContribution>
+ </extension>
+ <!-- Introduce Local Variable Refactoring -->
+ <extension point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.refactoring.ExtractVariableHandler"
+ commandId="org.eclipse.xtext.xbase.ui.refactoring.ExtractLocalVariable">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution
+ locationURI="popup:#TextEditorContext?after=group.edit">
+ <command commandId="org.eclipse.xtext.xbase.ui.refactoring.ExtractLocalVariable"
+ style="push">
+ <visibleWhen checkEnabled="false">
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <!-- Open implementation -->
+ <extension point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.navigation.OpenImplementationHandler"
+ commandId="org.eclipse.xtext.xbase.ui.OpenImplementationCommand">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution
+ locationURI="menu:navigate?after=open.ext4">
+ <command commandId="org.eclipse.xtext.xbase.ui.OpenImplementationCommand">
+ <visibleWhen checkEnabled="false">
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <extension point="org.eclipse.compare.contentViewers">
+ <viewer id="org.eclipse.osbp.xtext.oxtype.OXtype.compare.contentViewers"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.compare.InjectableViewerCreator"
+ extensions="oxtype">
+ </viewer>
+ </extension>
+ <extension point="org.eclipse.compare.contentMergeViewers">
+ <viewer id="org.eclipse.osbp.xtext.oxtype.OXtype.compare.contentMergeViewers"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.compare.InjectableViewerCreator"
+ extensions="oxtype" label="OXtype Compare">
+ </viewer>
+ </extension>
+ <extension point="org.eclipse.ui.editors.documentProviders">
+ <provider id="org.eclipse.osbp.xtext.oxtype.OXtype.editors.documentProviders"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.model.XtextDocumentProvider"
+ extensions="oxtype">
+ </provider>
+ </extension>
+ <extension point="org.eclipse.team.core.fileTypes">
+ <fileTypes
+ extension="oxtype"
+ type="text">
+ </fileTypes>
+ </extension>
+</plugin>
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/plugin.xml_gen b/org.eclipse.osbp.xtext.oxtype.ui/plugin.xml_gen
new file mode 100644
index 0000000..00a296d
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/plugin.xml_gen
@@ -0,0 +1,569 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+<plugin>
+ <extension
+ point="org.eclipse.ui.editors">
+ <editor
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.XtextEditor"
+ contributorClass="org.eclipse.ui.editors.text.TextEditorActionContributor"
+ default="true"
+ extensions="oxtype"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype"
+ matchingStrategy="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.editor.JavaEditorInputMatcher"
+ name="OXtype Editor">
+ </editor>
+ </extension>
+ <extension
+ point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclarationHandler"
+ commandId="org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclaration">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.handler.ValidateActionHandler"
+ commandId="org.eclipse.osbp.xtext.oxtype.OXtype.validate">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ <!-- copy qualified name -->
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedNameHandler"
+ commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName">
+ <activeWhen>
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+ </activeWhen>
+ </handler>
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedNameHandler"
+ commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedName">
+ <activeWhen>
+ <and>
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.XtextEditor.opened" />
+ <iterate>
+ <adapt type="org.eclipse.xtext.ui.editor.outline.IOutlineNode" />
+ </iterate>
+ </and>
+ </activeWhen>
+ </handler>
+ </extension>
+ <extension point="org.eclipse.core.expressions.definitions">
+ <definition id="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ <and>
+ <reference definitionId="isActiveEditorAnInstanceOfXtextEditor"/>
+ <with variable="activeEditor">
+ <test property="org.eclipse.xtext.ui.editor.XtextEditor.languageName"
+ value="org.eclipse.osbp.xtext.oxtype.OXtype"
+ forcePluginActivation="true"/>
+ </with>
+ </and>
+ </definition>
+ <definition id="org.eclipse.osbp.xtext.oxtype.OXtype.XtextEditor.opened">
+ <and>
+ <reference definitionId="isXtextEditorActive"/>
+ <with variable="activeEditor">
+ <test property="org.eclipse.xtext.ui.editor.XtextEditor.languageName"
+ value="org.eclipse.osbp.xtext.oxtype.OXtype"
+ forcePluginActivation="true"/>
+ </with>
+ </and>
+ </definition>
+ </extension>
+ <extension
+ point="org.eclipse.ui.preferencePages">
+ <page
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.preferences.LanguageRootPreferencePage"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype"
+ name="OXtype">
+ <keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+ </page>
+ <page
+ category="org.eclipse.osbp.xtext.oxtype.OXtype"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.syntaxcoloring.SyntaxColoringPreferencePage"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.coloring"
+ name="Syntax Coloring">
+ <keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+ </page>
+ <page
+ category="org.eclipse.osbp.xtext.oxtype.OXtype"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.templates.XtextTemplatePreferencePage"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.templates"
+ name="Templates">
+ <keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+ </page>
+ </extension>
+ <extension
+ point="org.eclipse.ui.propertyPages">
+ <page
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.preferences.LanguageRootPreferencePage"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype"
+ name="OXtype">
+ <keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+ <enabledWhen>
+ <adapt type="org.eclipse.core.resources.IProject"/>
+ </enabledWhen>
+ <filter name="projectNature" value="org.eclipse.xtext.ui.shared.xtextNature"/>
+ </page>
+ </extension>
+ <extension
+ point="org.eclipse.ui.keywords">
+ <keyword
+ id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"
+ label="OXtype"/>
+ </extension>
+ <extension
+ point="org.eclipse.ui.commands">
+ <command
+ description="Trigger expensive validation"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.validate"
+ name="Validate">
+ </command>
+ <!-- copy qualified name -->
+ <command
+ id="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName"
+ categoryId="org.eclipse.ui.category.edit"
+ description="Copy the qualified name for the selected element"
+ name="Copy Qualified Name">
+ </command>
+ <command
+ id="org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedName"
+ categoryId="org.eclipse.ui.category.edit"
+ description="Copy the qualified name for the selected element"
+ name="Copy Qualified Name">
+ </command>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution
+ locationURI="popup:#TextEditorContext?after=group.edit">
+ <command
+ commandId="org.eclipse.osbp.xtext.oxtype.OXtype.validate"
+ style="push"
+ tooltip="Trigger expensive validation">
+ <visibleWhen checkEnabled="false">
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ <!-- copy qualified name -->
+ <menuContribution locationURI="popup:#TextEditorContext?after=copy">
+ <command commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName"
+ style="push" tooltip="Copy Qualified Name">
+ <visibleWhen checkEnabled="false">
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ <menuContribution locationURI="menu:edit?after=copy">
+ <command commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName"
+ style="push" tooltip="Copy Qualified Name">
+ <visibleWhen checkEnabled="false">
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ <menuContribution locationURI="popup:org.eclipse.xtext.ui.outline?after=additions">
+ <command commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedName"
+ style="push" tooltip="Copy Qualified Name">
+ <visibleWhen checkEnabled="false">
+ <and>
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.XtextEditor.opened" />
+ <iterate>
+ <adapt type="org.eclipse.xtext.ui.editor.outline.IOutlineNode" />
+ </iterate>
+ </and>
+ </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.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <extension point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.findrefs.FindReferencesHandler"
+ commandId="org.eclipse.xtext.ui.editor.FindReferences">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+ <!-- adding resource factories -->
+ <extension
+ point="org.eclipse.emf.ecore.extension_parser">
+ <parser
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.resource.IResourceFactory"
+ type="oxtype">
+ </parser>
+ </extension>
+ <extension point="org.eclipse.xtext.extension_resourceServiceProvider">
+ <resourceServiceProvider
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.resource.IResourceUIServiceProvider"
+ uriExtension="oxtype">
+ </resourceServiceProvider>
+ </extension>
+ <!-- marker definitions for org.eclipse.osbp.xtext.oxtype.OXtype -->
+ <extension
+ id="oxtype.check.fast"
+ name="OXtype Problem"
+ point="org.eclipse.core.resources.markers">
+ <super type="org.eclipse.xtext.ui.check.fast"/>
+ <persistent value="true"/>
+ </extension>
+ <extension
+ id="oxtype.check.normal"
+ name="OXtype Problem"
+ point="org.eclipse.core.resources.markers">
+ <super type="org.eclipse.xtext.ui.check.normal"/>
+ <persistent value="true"/>
+ </extension>
+ <extension
+ id="oxtype.check.expensive"
+ name="OXtype Problem"
+ point="org.eclipse.core.resources.markers">
+ <super type="org.eclipse.xtext.ui.check.expensive"/>
+ <persistent value="true"/>
+ </extension>
+ <extension point="org.eclipse.xtext.builder.participant">
+ <participant
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.builder.IXtextBuilderParticipant"
+ fileExtensions="oxtype"/>
+ </extension>
+ <extension point="org.eclipse.ui.preferencePages">
+ <page
+ category="org.eclipse.osbp.xtext.oxtype.OXtype"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.builder.preferences.BuilderPreferencePage"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.compiler.preferencePage"
+ name="Compiler">
+ <keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+ </page>
+ </extension>
+ <extension point="org.eclipse.ui.propertyPages">
+ <page
+ category="org.eclipse.osbp.xtext.oxtype.OXtype"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.builder.preferences.BuilderPreferencePage"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.compiler.propertyPage"
+ name="Compiler">
+ <keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+ <enabledWhen>
+ <adapt type="org.eclipse.core.resources.IProject"/>
+ </enabledWhen>
+ <filter name="projectNature" value="org.eclipse.xtext.ui.shared.xtextNature"/>
+ </page>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution locationURI="popup:#TextEditorContext?after=xtext.ui.openDeclaration">
+ <command
+ commandId="org.eclipse.xtext.ui.OpenGeneratedFileCommand"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.OpenGeneratedCode"
+ style="push">
+ <visibleWhen checkEnabled="false">
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <extension point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.generator.trace.OpenGeneratedFileHandler"
+ commandId="org.eclipse.xtext.ui.OpenGeneratedFileCommand">
+ <activeWhen>
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+ </activeWhen>
+ </handler>
+ </extension>
+ <!-- Quick Outline -->
+ <extension
+ point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.outline.quickoutline.ShowQuickOutlineActionHandler"
+ commandId="org.eclipse.xtext.ui.editor.outline.QuickOutline">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.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.osbp.xtext.oxtype.OXtype.Editor.opened"/>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <!-- quickfix marker resolution generator for org.eclipse.osbp.xtext.oxtype.OXtype -->
+ <extension
+ point="org.eclipse.ui.ide.markerResolution">
+ <markerResolutionGenerator
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator"
+ markerType="org.eclipse.osbp.xtext.oxtype.ui.oxtype.check.fast">
+ <attribute
+ name="FIXABLE_KEY"
+ value="true">
+ </attribute>
+ </markerResolutionGenerator>
+ <markerResolutionGenerator
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator"
+ markerType="org.eclipse.osbp.xtext.oxtype.ui.oxtype.check.normal">
+ <attribute
+ name="FIXABLE_KEY"
+ value="true">
+ </attribute>
+ </markerResolutionGenerator>
+ <markerResolutionGenerator
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator"
+ markerType="org.eclipse.osbp.xtext.oxtype.ui.oxtype.check.expensive">
+ <attribute
+ name="FIXABLE_KEY"
+ value="true">
+ </attribute>
+ </markerResolutionGenerator>
+ </extension>
+ <!-- Rename Refactoring -->
+ <extension point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.refactoring.ui.DefaultRenameElementHandler"
+ commandId="org.eclipse.xtext.ui.refactoring.RenameElement">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution
+ locationURI="popup:#TextEditorContext?after=group.edit">
+ <command commandId="org.eclipse.xtext.ui.refactoring.RenameElement"
+ style="push">
+ <visibleWhen checkEnabled="false">
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <extension point="org.eclipse.ui.preferencePages">
+ <page
+ category="org.eclipse.osbp.xtext.oxtype.OXtype"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.refactoring.ui.RefactoringPreferencePage"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.refactoring"
+ name="Refactoring">
+ <keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+ </page>
+ </extension>
+ <!-- Type Hierarchy -->
+ <extension point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.hierarchy.OpenTypeHierarchyHandler"
+ commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenTypeHierarchy">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.hierarchy.QuickTypeHierarchyHandler"
+ commandId="org.eclipse.jdt.ui.edit.text.java.open.hierarchy">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution
+ locationURI="popup:#TextEditorContext?after=group.open">
+ <command commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenTypeHierarchy"
+ style="push"
+ tooltip="Open Type Hierarchy">
+ <visibleWhen checkEnabled="false">
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened"/>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ <menuContribution
+ locationURI="popup:#TextEditorContext?after=group.open">
+ <command commandId="org.eclipse.jdt.ui.edit.text.java.open.hierarchy"
+ style="push"
+ tooltip="Quick Type Hierarchy">
+ <visibleWhen checkEnabled="false">
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened"/>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <!-- Call Hierachy -->
+ <extension point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.hierarchy.OpenCallHierachyHandler"
+ commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenCallHierarchy">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution
+ locationURI="popup:#TextEditorContext?after=group.open">
+ <command commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenCallHierarchy"
+ style="push"
+ tooltip="Open Call Hierarchy">
+ <visibleWhen checkEnabled="false">
+ <reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened"/>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <extension point="org.eclipse.core.runtime.adapters">
+ <factory class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.builder.smap.StratumBreakpointAdapterFactory"
+ adaptableType="org.eclipse.xtext.ui.editor.XtextEditor">
+ <adapter type="org.eclipse.debug.ui.actions.IToggleBreakpointsTarget"/>
+ </factory>
+ </extension>
+ <extension point="org.eclipse.ui.editorActions">
+ <editorContribution targetID="org.eclipse.osbp.xtext.oxtype.OXtype"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.rulerActions">
+ <action
+ label="Not Used"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.debug.ui.actions.RulerToggleBreakpointActionDelegate"
+ style="push"
+ actionID="RulerDoubleClick"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.doubleClickBreakpointAction"/>
+ </editorContribution>
+ </extension>
+ <extension point="org.eclipse.ui.popupMenus">
+ <viewerContribution
+ targetID="org.eclipse.osbp.xtext.oxtype.OXtype.RulerContext"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.RulerPopupActions">
+ <action
+ label="Toggle Breakpoint"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.debug.ui.actions.RulerToggleBreakpointActionDelegate"
+ menubarPath="debug"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.rulerContextMenu.toggleBreakpointAction">
+ </action>
+ <action
+ label="Not used"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.debug.ui.actions.RulerEnableDisableBreakpointActionDelegate"
+ menubarPath="debug"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.rulerContextMenu.enableDisableBreakpointAction">
+ </action>
+ <action
+ label="Breakpoint Properties"
+ helpContextId="breakpoint_properties_action_context"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.jdt.debug.ui.actions.JavaBreakpointPropertiesRulerActionDelegate"
+ menubarPath="group.properties"
+ id="org.eclipse.osbp.xtext.oxtype.OXtype.rulerContextMenu.openBreapointPropertiesAction">
+ </action>
+ </viewerContribution>
+ </extension>
+ <!-- Introduce Local Variable Refactoring -->
+ <extension point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.refactoring.ExtractVariableHandler"
+ commandId="org.eclipse.xtext.xbase.ui.refactoring.ExtractLocalVariable">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution
+ locationURI="popup:#TextEditorContext?after=group.edit">
+ <command commandId="org.eclipse.xtext.xbase.ui.refactoring.ExtractLocalVariable"
+ style="push">
+ <visibleWhen checkEnabled="false">
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <!-- Open implementation -->
+ <extension point="org.eclipse.ui.handlers">
+ <handler
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.navigation.OpenImplementationHandler"
+ commandId="org.eclipse.xtext.xbase.ui.OpenImplementationCommand">
+ <activeWhen>
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </activeWhen>
+ </handler>
+ </extension>
+ <extension point="org.eclipse.ui.menus">
+ <menuContribution
+ locationURI="menu:navigate?after=open.ext4">
+ <command commandId="org.eclipse.xtext.xbase.ui.OpenImplementationCommand">
+ <visibleWhen checkEnabled="false">
+ <reference
+ definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+ </reference>
+ </visibleWhen>
+ </command>
+ </menuContribution>
+ </extension>
+ <extension point="org.eclipse.compare.contentViewers">
+ <viewer id="org.eclipse.osbp.xtext.oxtype.OXtype.compare.contentViewers"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.compare.InjectableViewerCreator"
+ extensions="oxtype">
+ </viewer>
+ </extension>
+ <extension point="org.eclipse.compare.contentMergeViewers">
+ <viewer id="org.eclipse.osbp.xtext.oxtype.OXtype.compare.contentMergeViewers"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.compare.InjectableViewerCreator"
+ extensions="oxtype" label="OXtype Compare">
+ </viewer>
+ </extension>
+ <extension point="org.eclipse.ui.editors.documentProviders">
+ <provider id="org.eclipse.osbp.xtext.oxtype.OXtype.editors.documentProviders"
+ class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.model.XtextDocumentProvider"
+ extensions="oxtype">
+ </provider>
+ </extension>
+ <extension point="org.eclipse.team.core.fileTypes">
+ <fileTypes
+ extension="oxtype"
+ type="text">
+ </fileTypes>
+ </extension>
+</plugin>
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/pom.xml b/org.eclipse.osbp.xtext.oxtype.ui/pom.xml
new file mode 100644
index 0000000..fb833d6
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/pom.xml
@@ -0,0 +1,22 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.eclipse.osbp.xtext.oxtype</groupId>
+ <artifactId>org.eclipse.osbp.xtext.oxtype.aggregator</artifactId>
+ <version>0.9.0-SNAPSHOT</version>
+ <relativePath>..</relativePath>
+ </parent>
+ <artifactId>org.eclipse.osbp.xtext.oxtype.ui</artifactId>
+ <packaging>eclipse-plugin</packaging>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.eclipse.xtend</groupId>
+ <artifactId>xtend-maven-plugin</artifactId>
+ </plugin>
+ </plugins>
+ </build>
+
+</project>
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/AbstractOXtypeUiModule.java b/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/AbstractOXtypeUiModule.java
new file mode 100644
index 0000000..62b506a
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/AbstractOXtypeUiModule.java
@@ -0,0 +1,381 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui;
+
+import com.google.inject.Binder;
+import com.google.inject.Provider;
+import com.google.inject.name.Names;
+import org.eclipse.compare.IViewerCreator;
+import org.eclipse.core.resources.IWorkspaceRoot;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.jface.viewers.ILabelProvider;
+import org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.OXtypeParser;
+import org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.PartialOXtypeContentAssistParser;
+import org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.internal.InternalOXtypeLexer;
+import org.eclipse.osbp.xtext.oxtype.ui.contentassist.OXtypeProposalProvider;
+import org.eclipse.osbp.xtext.oxtype.ui.labeling.OXtypeDescriptionLabelProvider;
+import org.eclipse.osbp.xtext.oxtype.ui.labeling.OXtypeLabelProvider;
+import org.eclipse.osbp.xtext.oxtype.ui.outline.OXtypeOutlineTreeProvider;
+import org.eclipse.osbp.xtext.oxtype.ui.quickfix.OXtypeQuickfixProvider;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+import org.eclipse.xtext.builder.BuilderParticipant;
+import org.eclipse.xtext.builder.EclipseOutputConfigurationProvider;
+import org.eclipse.xtext.builder.IXtextBuilderParticipant;
+import org.eclipse.xtext.builder.builderState.IBuilderState;
+import org.eclipse.xtext.builder.clustering.CurrentDescriptions;
+import org.eclipse.xtext.builder.impl.PersistentDataAwareDirtyResource;
+import org.eclipse.xtext.builder.nature.NatureAddingEditorCallback;
+import org.eclipse.xtext.builder.preferences.BuilderPreferenceAccess;
+import org.eclipse.xtext.common.types.ui.navigation.GlobalDerivedMemberAwareURIEditorOpener;
+import org.eclipse.xtext.common.types.ui.navigation.IDerivedMemberAwareEditorOpener;
+import org.eclipse.xtext.common.types.ui.query.IJavaSearchParticipation;
+import org.eclipse.xtext.common.types.ui.refactoring.JdtRenameSupport;
+import org.eclipse.xtext.common.types.ui.refactoring.participant.JdtRenameParticipant;
+import org.eclipse.xtext.common.types.ui.refactoring.participant.JvmMemberRenameStrategy;
+import org.eclipse.xtext.generator.IContextualOutputConfigurationProvider;
+import org.eclipse.xtext.ide.LexerIdeBindings;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.IContentAssistParser;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer;
+import org.eclipse.xtext.ide.editor.partialEditing.IPartialEditingContentAssistParser;
+import org.eclipse.xtext.parser.antlr.AntlrTokenDefProvider;
+import org.eclipse.xtext.parser.antlr.ITokenDefProvider;
+import org.eclipse.xtext.parser.antlr.LexerProvider;
+import org.eclipse.xtext.resource.IResourceDescriptions;
+import org.eclipse.xtext.resource.containers.IAllContainersState;
+import org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider;
+import org.eclipse.xtext.service.SingletonBinding;
+import org.eclipse.xtext.ui.LanguageSpecific;
+import org.eclipse.xtext.ui.codetemplates.ui.AccessibleCodetemplatesActivator;
+import org.eclipse.xtext.ui.codetemplates.ui.partialEditing.IPartialEditingContentAssistContextFactory;
+import org.eclipse.xtext.ui.codetemplates.ui.partialEditing.PartialEditingContentAssistContextFactory;
+import org.eclipse.xtext.ui.codetemplates.ui.preferences.AdvancedTemplatesPreferencePage;
+import org.eclipse.xtext.ui.codetemplates.ui.preferences.TemplatesLanguageConfiguration;
+import org.eclipse.xtext.ui.codetemplates.ui.registry.LanguageRegistrar;
+import org.eclipse.xtext.ui.codetemplates.ui.registry.LanguageRegistry;
+import org.eclipse.xtext.ui.compare.DefaultViewerCreator;
+import org.eclipse.xtext.ui.editor.DocumentBasedDirtyResource;
+import org.eclipse.xtext.ui.editor.GlobalURIEditorOpener;
+import org.eclipse.xtext.ui.editor.IURIEditorOpener;
+import org.eclipse.xtext.ui.editor.IXtextEditorCallback;
+import org.eclipse.xtext.ui.editor.XtextEditor;
+import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext;
+import org.eclipse.xtext.ui.editor.contentassist.FQNPrefixMatcher;
+import org.eclipse.xtext.ui.editor.contentassist.IContentProposalProvider;
+import org.eclipse.xtext.ui.editor.contentassist.IProposalConflictHelper;
+import org.eclipse.xtext.ui.editor.contentassist.PrefixMatcher;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.AntlrProposalConflictHelper;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.DelegatingContentAssistContextFactory;
+import org.eclipse.xtext.ui.editor.findrefs.FindReferencesHandler;
+import org.eclipse.xtext.ui.editor.findrefs.ReferenceQueryExecutor;
+import org.eclipse.xtext.ui.editor.model.XtextDocumentProvider;
+import org.eclipse.xtext.ui.editor.outline.IOutlineTreeProvider;
+import org.eclipse.xtext.ui.editor.outline.impl.IOutlineTreeStructureProvider;
+import org.eclipse.xtext.ui.editor.outline.impl.OutlineNodeElementOpener;
+import org.eclipse.xtext.ui.editor.preferences.IPreferenceStoreInitializer;
+import org.eclipse.xtext.ui.editor.quickfix.IssueResolutionProvider;
+import org.eclipse.xtext.ui.editor.templates.XtextTemplatePreferencePage;
+import org.eclipse.xtext.ui.generator.trace.OpenGeneratedFileHandler;
+import org.eclipse.xtext.ui.refactoring.IDependentElementsCalculator;
+import org.eclipse.xtext.ui.refactoring.IReferenceUpdater;
+import org.eclipse.xtext.ui.refactoring.IRenameRefactoringProvider;
+import org.eclipse.xtext.ui.refactoring.IRenameStrategy;
+import org.eclipse.xtext.ui.refactoring.impl.DefaultRenameStrategyProvider;
+import org.eclipse.xtext.ui.refactoring.ui.IRenameContextFactory;
+import org.eclipse.xtext.ui.refactoring.ui.IRenameSupport;
+import org.eclipse.xtext.ui.refactoring.ui.RefactoringPreferences;
+import org.eclipse.xtext.ui.resource.ResourceServiceDescriptionLabelProvider;
+import org.eclipse.xtext.ui.shared.Access;
+import org.eclipse.xtext.xbase.annotations.ui.DefaultXbaseWithAnnotationsUiModule;
+import org.eclipse.xtext.xbase.ui.editor.XbaseDocumentProvider;
+import org.eclipse.xtext.xbase.ui.editor.XbaseEditor;
+import org.eclipse.xtext.xbase.ui.generator.trace.XbaseOpenGeneratedFileHandler;
+import org.eclipse.xtext.xbase.ui.jvmmodel.findrefs.JvmModelFindReferenceHandler;
+import org.eclipse.xtext.xbase.ui.jvmmodel.findrefs.JvmModelReferenceQueryExecutor;
+import org.eclipse.xtext.xbase.ui.jvmmodel.navigation.DerivedMemberAwareEditorOpener;
+import org.eclipse.xtext.xbase.ui.jvmmodel.outline.JvmOutlineNodeElementOpener;
+import org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.DefaultJvmModelRenameStrategy;
+import org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.JvmModelDependentElementsCalculator;
+import org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.JvmModelJdtRenameParticipantContext;
+import org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.jdt.CombinedJvmJdtRenameContextFactory;
+import org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.jdt.CombinedJvmJdtRenameRefactoringProvider;
+import org.eclipse.xtext.xbase.ui.quickfix.JavaTypeQuickfixes;
+import org.eclipse.xtext.xbase.ui.quickfix.JavaTypeQuickfixesNoImportSection;
+import org.eclipse.xtext.xbase.ui.refactoring.XbaseReferenceUpdater;
+
+/**
+ * Manual modifications go to {@link OXtypeUiModule}.
+ */
+@SuppressWarnings("all")
+public abstract class AbstractOXtypeUiModule extends DefaultXbaseWithAnnotationsUiModule {
+
+ public AbstractOXtypeUiModule(AbstractUIPlugin plugin) {
+ super(plugin);
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ImplicitFragment
+ public Provider<? extends IAllContainersState> provideIAllContainersState() {
+ return Access.getJavaProjectsState();
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ImplicitFragment
+ public Class<? extends XtextEditor> bindXtextEditor() {
+ return XbaseEditor.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ImplicitFragment
+ public Class<? extends XtextDocumentProvider> bindXtextDocumentProvider() {
+ return XbaseDocumentProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ImplicitFragment
+ public Class<? extends OpenGeneratedFileHandler> bindOpenGeneratedFileHandler() {
+ return XbaseOpenGeneratedFileHandler.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public Class<? extends IProposalConflictHelper> bindIProposalConflictHelper() {
+ return AntlrProposalConflictHelper.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public void configureContentAssistLexer(Binder binder) {
+ binder.bind(Lexer.class)
+ .annotatedWith(Names.named(LexerIdeBindings.CONTENT_ASSIST))
+ .to(InternalOXtypeLexer.class);
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public void configureHighlightingLexer(Binder binder) {
+ binder.bind(org.eclipse.xtext.parser.antlr.Lexer.class)
+ .annotatedWith(Names.named(LexerIdeBindings.HIGHLIGHTING))
+ .to(org.eclipse.osbp.xtext.oxtype.parser.antlr.internal.InternalOXtypeLexer.class);
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public void configureHighlightingTokenDefProvider(Binder binder) {
+ binder.bind(ITokenDefProvider.class)
+ .annotatedWith(Names.named(LexerIdeBindings.HIGHLIGHTING))
+ .to(AntlrTokenDefProvider.class);
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public Class<? extends ContentAssistContext.Factory> bindContentAssistContext$Factory() {
+ return DelegatingContentAssistContextFactory.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public Class<? extends IContentAssistParser> bindIContentAssistParser() {
+ return OXtypeParser.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public void configureContentAssistLexerProvider(Binder binder) {
+ binder.bind(InternalOXtypeLexer.class).toProvider(LexerProvider.create(InternalOXtypeLexer.class));
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+ public void configureIResourceDescriptionsBuilderScope(Binder binder) {
+ binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.NAMED_BUILDER_SCOPE)).to(CurrentDescriptions.ResourceSetAware.class);
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+ public Class<? extends IXtextEditorCallback> bindIXtextEditorCallback() {
+ return NatureAddingEditorCallback.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+ public Class<? extends IContextualOutputConfigurationProvider> bindIContextualOutputConfigurationProvider() {
+ return EclipseOutputConfigurationProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+ public void configureIResourceDescriptionsPersisted(Binder binder) {
+ binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.PERSISTED_DESCRIPTIONS)).to(IBuilderState.class);
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+ public Class<? extends DocumentBasedDirtyResource> bindDocumentBasedDirtyResource() {
+ return PersistentDataAwareDirtyResource.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2
+ public Class<? extends IXtextBuilderParticipant> bindIXtextBuilderParticipant() {
+ return BuilderParticipant.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2
+ public IWorkspaceRoot bindIWorkspaceRootToInstance() {
+ return ResourcesPlugin.getWorkspace().getRoot();
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2
+ public void configureBuilderPreferenceStoreInitializer(Binder binder) {
+ binder.bind(IPreferenceStoreInitializer.class)
+ .annotatedWith(Names.named("builderPreferenceInitializer"))
+ .to(BuilderPreferenceAccess.Initializer.class);
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ui.labeling.LabelProviderFragment2
+ public Class<? extends ILabelProvider> bindILabelProvider() {
+ return OXtypeLabelProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ui.labeling.LabelProviderFragment2
+ public void configureResourceUIServiceLabelProvider(Binder binder) {
+ binder.bind(ILabelProvider.class).annotatedWith(ResourceServiceDescriptionLabelProvider.class).to(OXtypeDescriptionLabelProvider.class);
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ui.outline.OutlineTreeProviderFragment2
+ public Class<? extends IOutlineTreeProvider> bindIOutlineTreeProvider() {
+ return OXtypeOutlineTreeProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ui.outline.OutlineTreeProviderFragment2
+ public Class<? extends IOutlineTreeStructureProvider> bindIOutlineTreeStructureProvider() {
+ return OXtypeOutlineTreeProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ui.quickfix.QuickfixProviderFragment2
+ public Class<? extends IssueResolutionProvider> bindIssueResolutionProvider() {
+ return OXtypeQuickfixProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ui.contentAssist.ContentAssistFragment2
+ public Class<? extends IContentProposalProvider> bindIContentProposalProvider() {
+ return OXtypeProposalProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2
+ public void configureIPreferenceStoreInitializer(Binder binder) {
+ binder.bind(IPreferenceStoreInitializer.class)
+ .annotatedWith(Names.named("RefactoringPreferences"))
+ .to(RefactoringPreferences.Initializer.class);
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2
+ public Class<? extends IRenameSupport.Factory> bindIRenameSupport$Factory() {
+ return JdtRenameSupport.Factory.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2
+ public Class<? extends IRenameStrategy.Provider> bindIRenameStrategy$Provider() {
+ return JvmMemberRenameStrategy.Provider.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2
+ public void configureJvmMemberRenameStrategy$Provider$Delegate(Binder binder) {
+ binder.bind(IRenameStrategy.Provider.class).annotatedWith(JvmMemberRenameStrategy.Provider.Delegate.class).to(DefaultRenameStrategyProvider.class);
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.types.TypesGeneratorFragment2
+ public Class<? extends PrefixMatcher> bindPrefixMatcher() {
+ return FQNPrefixMatcher.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends FindReferencesHandler> bindFindReferencesHandler() {
+ return JvmModelFindReferenceHandler.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends ReferenceQueryExecutor> bindReferenceQueryExecutor() {
+ return JvmModelReferenceQueryExecutor.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends IDependentElementsCalculator> bindIDependentElementsCalculator() {
+ return JvmModelDependentElementsCalculator.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends IRenameRefactoringProvider> bindIRenameRefactoringProvider() {
+ return CombinedJvmJdtRenameRefactoringProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends IReferenceUpdater> bindIReferenceUpdater() {
+ return XbaseReferenceUpdater.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends IRenameContextFactory> bindIRenameContextFactory() {
+ return CombinedJvmJdtRenameContextFactory.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends IRenameStrategy> bindIRenameStrategy() {
+ return DefaultJvmModelRenameStrategy.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends JdtRenameParticipant.ContextFactory> bindJdtRenameParticipant$ContextFactory() {
+ return JvmModelJdtRenameParticipantContext.ContextFactory.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends OutlineNodeElementOpener> bindOutlineNodeElementOpener() {
+ return JvmOutlineNodeElementOpener.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends GlobalURIEditorOpener> bindGlobalURIEditorOpener() {
+ return GlobalDerivedMemberAwareURIEditorOpener.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends IJavaSearchParticipation> bindIJavaSearchParticipation() {
+ return IJavaSearchParticipation.No.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public void configureLanguageSpecificURIEditorOpener(Binder binder) {
+ if (PlatformUI.isWorkbenchRunning()) {
+ binder.bind(IURIEditorOpener.class).annotatedWith(LanguageSpecific.class).to(DerivedMemberAwareEditorOpener.class);
+ binder.bind(IDerivedMemberAwareEditorOpener.class).to(DerivedMemberAwareEditorOpener.class);
+ }
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends JavaTypeQuickfixes> bindJavaTypeQuickfixes() {
+ return JavaTypeQuickfixesNoImportSection.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2
+ public Provider<? extends TemplatesLanguageConfiguration> provideTemplatesLanguageConfiguration() {
+ return AccessibleCodetemplatesActivator.getTemplatesLanguageConfigurationProvider();
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2
+ public Provider<? extends LanguageRegistry> provideLanguageRegistry() {
+ return AccessibleCodetemplatesActivator.getLanguageRegistry();
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2
+ @SingletonBinding(eager=true)
+ public Class<? extends LanguageRegistrar> bindLanguageRegistrar() {
+ return LanguageRegistrar.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2
+ public Class<? extends XtextTemplatePreferencePage> bindXtextTemplatePreferencePage() {
+ return AdvancedTemplatesPreferencePage.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2
+ public Class<? extends IPartialEditingContentAssistParser> bindIPartialEditingContentAssistParser() {
+ return PartialOXtypeContentAssistParser.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2
+ public Class<? extends IPartialEditingContentAssistContextFactory> bindIPartialEditingContentAssistContextFactory() {
+ return PartialEditingContentAssistContextFactory.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.ui.compare.CompareFragment2
+ public Class<? extends IViewerCreator> bindIViewerCreator() {
+ return DefaultViewerCreator.class;
+ }
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/OXtypeExecutableExtensionFactory.java b/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/OXtypeExecutableExtensionFactory.java
new file mode 100644
index 0000000..aa92e60
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/OXtypeExecutableExtensionFactory.java
@@ -0,0 +1,27 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui;
+
+import com.google.inject.Injector;
+import org.eclipse.osbp.xtext.oxtype.ui.internal.OxtypeActivator;
+import org.eclipse.xtext.ui.guice.AbstractGuiceAwareExecutableExtensionFactory;
+import org.osgi.framework.Bundle;
+
+/**
+ * This class was generated. Customizations should only happen in a newly
+ * introduced subclass.
+ */
+public class OXtypeExecutableExtensionFactory extends AbstractGuiceAwareExecutableExtensionFactory {
+
+ @Override
+ protected Bundle getBundle() {
+ return OxtypeActivator.getInstance().getBundle();
+ }
+
+ @Override
+ protected Injector getInjector() {
+ return OxtypeActivator.getInstance().getInjector(OxtypeActivator.ORG_ECLIPSE_OSBP_XTEXT_OXTYPE_OXTYPE);
+ }
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/contentassist/AbstractOXtypeProposalProvider.java b/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/contentassist/AbstractOXtypeProposalProvider.java
new file mode 100644
index 0000000..7bad6f1
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/contentassist/AbstractOXtypeProposalProvider.java
@@ -0,0 +1,27 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui.contentassist;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.Assignment;
+import org.eclipse.xtext.RuleCall;
+import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext;
+import org.eclipse.xtext.ui.editor.contentassist.ICompletionProposalAcceptor;
+import org.eclipse.xtext.xbase.annotations.ui.contentassist.XbaseWithAnnotationsProposalProvider;
+
+/**
+ * Represents a generated, default implementation of superclass {@link XbaseWithAnnotationsProposalProvider}.
+ * Methods are dynamically dispatched on the first parameter, i.e., you can override them
+ * with a more concrete subtype.
+ */
+public abstract class AbstractOXtypeProposalProvider extends XbaseWithAnnotationsProposalProvider {
+
+ public void completeXImportDeclaration_FqnImport(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void completeXImportDeclaration_ImportedFullyQualifiedName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/internal/OxtypeActivator.java b/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/internal/OxtypeActivator.java
new file mode 100644
index 0000000..426ca17
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/internal/OxtypeActivator.java
@@ -0,0 +1,93 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui.internal;
+
+import com.google.common.collect.Maps;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.google.inject.Module;
+import java.util.Collections;
+import java.util.Map;
+import org.apache.log4j.Logger;
+import org.eclipse.osbp.xtext.oxtype.OXtypeRuntimeModule;
+import org.eclipse.osbp.xtext.oxtype.ui.OXtypeUiModule;
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+import org.eclipse.xtext.ui.shared.SharedStateModule;
+import org.eclipse.xtext.util.Modules2;
+import org.osgi.framework.BundleContext;
+
+/**
+ * This class was generated. Customizations should only happen in a newly
+ * introduced subclass.
+ */
+public class OxtypeActivator extends AbstractUIPlugin {
+
+ public static final String ORG_ECLIPSE_OSBP_XTEXT_OXTYPE_OXTYPE = "org.eclipse.osbp.xtext.oxtype.OXtype";
+
+ private static final Logger logger = Logger.getLogger(OxtypeActivator.class);
+
+ private static OxtypeActivator INSTANCE;
+
+ private Map<String, Injector> injectors = Collections.synchronizedMap(Maps.<String, Injector> newHashMapWithExpectedSize(1));
+
+ @Override
+ public void start(BundleContext context) throws Exception {
+ super.start(context);
+ INSTANCE = this;
+ }
+
+ @Override
+ public void stop(BundleContext context) throws Exception {
+ injectors.clear();
+ INSTANCE = null;
+ super.stop(context);
+ }
+
+ public static OxtypeActivator getInstance() {
+ return INSTANCE;
+ }
+
+ public Injector getInjector(String language) {
+ synchronized (injectors) {
+ Injector injector = injectors.get(language);
+ if (injector == null) {
+ injectors.put(language, injector = createInjector(language));
+ }
+ return injector;
+ }
+ }
+
+ protected Injector createInjector(String language) {
+ try {
+ Module runtimeModule = getRuntimeModule(language);
+ Module sharedStateModule = getSharedStateModule();
+ Module uiModule = getUiModule(language);
+ Module mergedModule = Modules2.mixin(runtimeModule, sharedStateModule, uiModule);
+ return Guice.createInjector(mergedModule);
+ } catch (Exception e) {
+ logger.error("Failed to create injector for " + language);
+ logger.error(e.getMessage(), e);
+ throw new RuntimeException("Failed to create injector for " + language, e);
+ }
+ }
+
+ protected Module getRuntimeModule(String grammar) {
+ if (ORG_ECLIPSE_OSBP_XTEXT_OXTYPE_OXTYPE.equals(grammar)) {
+ return new OXtypeRuntimeModule();
+ }
+ throw new IllegalArgumentException(grammar);
+ }
+
+ protected Module getUiModule(String grammar) {
+ if (ORG_ECLIPSE_OSBP_XTEXT_OXTYPE_OXTYPE.equals(grammar)) {
+ return new OXtypeUiModule(this);
+ }
+ throw new IllegalArgumentException(grammar);
+ }
+
+ protected Module getSharedStateModule() {
+ return new SharedStateModule();
+ }
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/OXtypeUiModule.xtend b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/OXtypeUiModule.xtend
new file mode 100644
index 0000000..f9d994a
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/OXtypeUiModule.xtend
@@ -0,0 +1,16 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui
+
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+import org.eclipse.ui.plugin.AbstractUIPlugin
+
+/**
+ * Use this class to register components to be used within the Eclipse IDE.
+ */
+@FinalFieldsConstructor
+class OXtypeUiModule extends AbstractOXtypeUiModule {
+
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/contentassist/OXtypeProposalProvider.xtend b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/contentassist/OXtypeProposalProvider.xtend
new file mode 100644
index 0000000..58260a2
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/contentassist/OXtypeProposalProvider.xtend
@@ -0,0 +1,12 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui.contentassist
+
+
+/**
+ * See https://www.eclipse.org/Xtext/documentation/304_ide_concepts.html#content-assist
+ * on how to customize the content assistant.
+ */
+class OXtypeProposalProvider extends AbstractOXtypeProposalProvider {
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/labeling/OXtypeDescriptionLabelProvider.xtend b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/labeling/OXtypeDescriptionLabelProvider.xtend
new file mode 100644
index 0000000..f05419b
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/labeling/OXtypeDescriptionLabelProvider.xtend
@@ -0,0 +1,24 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui.labeling
+
+import org.eclipse.xtext.xbase.ui.labeling.XbaseDescriptionLabelProvider
+
+/**
+ * Provides labels for IEObjectDescriptions and IResourceDescriptions.
+ *
+ * See https://www.eclipse.org/Xtext/documentation/304_ide_concepts.html#label-provider
+ */
+class OXtypeDescriptionLabelProvider extends XbaseDescriptionLabelProvider {
+
+ // Labels and icons can be computed like this:
+
+// override text(IEObjectDescription ele) {
+// ele.name.toString
+// }
+//
+// override image(IEObjectDescription ele) {
+// ele.EClass.name + '.gif'
+// }
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/labeling/OXtypeLabelProvider.xtend b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/labeling/OXtypeLabelProvider.xtend
new file mode 100644
index 0000000..28831f7
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/labeling/OXtypeLabelProvider.xtend
@@ -0,0 +1,31 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui.labeling
+
+import com.google.inject.Inject
+import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider
+import org.eclipse.xtext.xbase.ui.labeling.XbaseLabelProvider
+
+/**
+ * Provides labels for EObjects.
+ *
+ * See https://www.eclipse.org/Xtext/documentation/304_ide_concepts.html#label-provider
+ */
+class OXtypeLabelProvider extends XbaseLabelProvider {
+
+ @Inject
+ new(AdapterFactoryLabelProvider delegate) {
+ super(delegate);
+ }
+
+ // Labels and icons can be computed like this:
+
+// def text(Greeting ele) {
+// 'A greeting to ' + ele.name
+// }
+//
+// def image(Greeting ele) {
+// 'Greeting.gif'
+// }
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/outline/OXtypeOutlineTreeProvider.xtend b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/outline/OXtypeOutlineTreeProvider.xtend
new file mode 100644
index 0000000..ef5d958
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/outline/OXtypeOutlineTreeProvider.xtend
@@ -0,0 +1,15 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui.outline
+
+import org.eclipse.xtext.ui.editor.outline.impl.DefaultOutlineTreeProvider
+
+/**
+ * Customization of the default outline structure.
+ *
+ * See https://www.eclipse.org/Xtext/documentation/304_ide_concepts.html#outline
+ */
+class OXtypeOutlineTreeProvider extends DefaultOutlineTreeProvider {
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/quickfix/OXtypeQuickfixProvider.xtend b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/quickfix/OXtypeQuickfixProvider.xtend
new file mode 100644
index 0000000..316c32e
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/quickfix/OXtypeQuickfixProvider.xtend
@@ -0,0 +1,24 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui.quickfix
+
+import org.eclipse.xtext.xbase.annotations.ui.quickfix.XbaseWithAnnotationsQuickfixProvider
+
+/**
+ * Custom quickfixes.
+ *
+ * See https://www.eclipse.org/Xtext/documentation/310_eclipse_support.html#quick-fixes
+ */
+class OXtypeQuickfixProvider extends XbaseWithAnnotationsQuickfixProvider {
+
+// @Fix(OXtypeValidator.INVALID_NAME)
+// def capitalizeName(Issue issue, IssueResolutionAcceptor acceptor) {
+// acceptor.accept(issue, 'Capitalize name', 'Capitalize the name.', 'upcase.png') [
+// context |
+// val xtextDocument = context.xtextDocument
+// val firstLetter = xtextDocument.get(issue.offset, 1)
+// xtextDocument.replace(issue.offset, 1, firstLetter.toUpperCase)
+// ]
+// }
+}
diff --git "a/org.eclipse.osbp.xtext.oxtype/.launch/Generate OXtype \050oxtype\051 Language Infrastructure.launch" "b/org.eclipse.osbp.xtext.oxtype/.launch/Generate OXtype \050oxtype\051 Language Infrastructure.launch"
new file mode 100644
index 0000000..2c0ced0
--- /dev/null
+++ "b/org.eclipse.osbp.xtext.oxtype/.launch/Generate OXtype \050oxtype\051 Language Infrastructure.launch"
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<launchConfiguration type="org.eclipse.emf.mwe2.launch.Mwe2LaunchConfigurationType">
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
+<listEntry value="/org.eclipse.osbp.xtext.oxtype"/>
+</listAttribute>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
+<listEntry value="4"/>
+</listAttribute>
+<listAttribute key="org.eclipse.debug.ui.favoriteGroups">
+<listEntry value="org.eclipse.debug.ui.launchGroup.debug"/>
+<listEntry value="org.eclipse.debug.ui.launchGroup.run"/>
+</listAttribute>
+<stringAttribute key="org.eclipse.debug.core.ATTR_REFRESH_SCOPE" value="${working_set:<?xml version="1.0" encoding="UTF-8"?> <resources> <item path="/org.eclipse.osbp.xtext.oxtype.parent" type="4"/> <item path="/org.eclipse.osbp.xtext.oxtype" type="4"/> <item path="/org.eclipse.osbp.xtext.oxtype.ide" type="4"/> <item path="/org.eclipse.osbp.xtext.oxtype.ui" type="4"/> <item path="/org.eclipse.osbp.xtext.oxtype.target" type="4"/> <item path="/org.eclipse.osbp.xtext.oxtype.tests" type="4"/> <item path="/org.eclipse.osbp.xtext.oxtype.ui.tests" type="4"/> <item path="/org.eclipse.osbp.xtext.oxtype.tests" type="4"/> <item path="/org.eclipse.osbp.xtext.oxtype.ui.tests" type="4"/> ;</resources>}"/>
+<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.emf.mwe2.launch.runtime.Mwe2Launcher"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="org.eclipse.osbp.xtext.oxtype.GenerateOXtype"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.osbp.xtext.oxtype"/>
+<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Xmx512m"/>
+</launchConfiguration>
diff --git a/org.eclipse.osbp.xtext.oxtype/.project b/org.eclipse.osbp.xtext.oxtype/.project
new file mode 100644
index 0000000..0eb3ef4
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>org.eclipse.osbp.xtext.oxtype</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.m2e.core.maven2Builder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <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.m2e.core.maven2Nature</nature>
+ <nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ <nature>org.eclipse.pde.PluginNature</nature>
+ </natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.xtext.oxtype/META-INF/MANIFEST.MF b/org.eclipse.osbp.xtext.oxtype/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..ca03f2e
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/META-INF/MANIFEST.MF
@@ -0,0 +1,32 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.osbp.xtext.oxtype
+Bundle-Vendor: Eclipse OSBP
+Bundle-Version: 0.9.0.qualifier
+Bundle-SymbolicName: org.eclipse.osbp.xtext.oxtype; singleton:=true
+Bundle-ActivationPolicy: lazy
+Require-Bundle: org.eclipse.xtext,
+ org.eclipse.xtext.xbase,
+ org.eclipse.equinox.common;bundle-version="3.5.0",
+ org.eclipse.emf.ecore,
+ org.eclipse.xtext.common.types,
+ org.eclipse.xtext.xbase.lib,
+ org.antlr.runtime,
+ org.objectweb.asm;bundle-version="[5.0.1,6.0.0)";resolution:=optional,
+ org.eclipse.xtext.util,
+ org.eclipse.xtend.lib,
+ org.eclipse.emf.common
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Import-Package: org.apache.log4j,
+ org.slf4j;version="1.7.2"
+Export-Package: org.eclipse.osbp.xtext.oxtype;x-internal:=true,
+ org.eclipse.osbp.xtext.oxtype.jvmmodel;x-internal:=true,
+ org.eclipse.osbp.xtext.oxtype.oxtype,
+ org.eclipse.osbp.xtext.oxtype.oxtype.impl;x-internal:=true,
+ org.eclipse.osbp.xtext.oxtype.oxtype.util,
+ org.eclipse.osbp.xtext.oxtype.parser.antlr;x-internal:=true,
+ org.eclipse.osbp.xtext.oxtype.parser.antlr.internal;x-internal:=true,
+ org.eclipse.osbp.xtext.oxtype.scoping,
+ org.eclipse.osbp.xtext.oxtype.serializer;x-internal:=true,
+ org.eclipse.osbp.xtext.oxtype.services;x-internal:=true,
+ org.eclipse.osbp.xtext.oxtype.validation;x-internal:=true
diff --git a/org.eclipse.osbp.xtext.oxtype/build.properties b/org.eclipse.osbp.xtext.oxtype/build.properties
new file mode 100644
index 0000000..18d540b
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/build.properties
@@ -0,0 +1,20 @@
+source.. = src/,\
+ src-gen/,\
+ xtend-gen/
+bin.includes = model/generated/,\
+ .,\
+ META-INF/,\
+ plugin.xml
+bin.excludes = **/*.mwe2,\
+ **/*.xtend
+additional.bundles = org.eclipse.xtext.xbase,\
+ org.eclipse.xtext.common.types,\
+ org.eclipse.xtext.xtext.generator,\
+ org.eclipse.emf.codegen.ecore,\
+ org.eclipse.emf.mwe.utils,\
+ org.eclipse.emf.mwe2.launch,\
+ org.eclipse.emf.mwe2.lib,\
+ org.objectweb.asm,\
+ org.apache.commons.logging,\
+ org.apache.log4j,\
+ com.ibm.icu
diff --git a/org.eclipse.osbp.xtext.oxtype/model/OXtype.ecore b/org.eclipse.osbp.xtext.oxtype/model/OXtype.ecore
new file mode 100644
index 0000000..63a4cd1
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/model/OXtype.ecore
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="oxtype" nsURI="http://www.eclipse.org/osbp/xtext/oxtype/OXtype"
+ nsPrefix="oxtype">
+ <eClassifiers xsi:type="ecore:EClass" name="OXImportDeclaration" eSuperTypes="../../org.eclipse.xtext.xbase/model/Xtype.ecore#//XImportDeclaration">
+ <eStructuralFeatures xsi:type="ecore:EAttribute" name="fqnImport" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+ <eStructuralFeatures xsi:type="ecore:EAttribute" name="importedFullyQualifiedName"
+ eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+ </eClassifiers>
+</ecore:EPackage>
diff --git a/org.eclipse.osbp.xtext.oxtype/model/OXtype.genmodel b/org.eclipse.osbp.xtext.oxtype/model/OXtype.genmodel
new file mode 100644
index 0000000..9e5a89c
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/model/OXtype.genmodel
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<genmodel:GenModel xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
+ xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText="generated by Xtext 2.11.0.beta2" modelDirectory="/org.eclipse.osbp.xtext.oxtype/src"
+ modelPluginID="org.eclipse.osbp.xtext.oxtype" forceOverwrite="true" modelName="OXtype"
+ updateClasspath="false" rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container"
+ complianceLevel="6.0" copyrightFields="false" runtimeVersion="2.13" usedGenPackages="../../org.eclipse.xtext.xbase/model/Xbase.genmodel#//xtype ../../org.eclipse.xtext.common.types/model/JavaVMTypes.genmodel#//types">
+ <genPackages prefix="OXtype" basePackage="org.eclipse.osbp.xtext.oxtype" disposableProviderFactory="true"
+ fileExtensions="oxtype" ecorePackage="OXtype.ecore#/">
+ <genClasses ecoreClass="OXtype.ecore#//OXImportDeclaration">
+ <genFeatures createChild="false" ecoreFeature="ecore:EAttribute OXtype.ecore#//OXImportDeclaration/fqnImport"/>
+ <genFeatures createChild="false" ecoreFeature="ecore:EAttribute OXtype.ecore#//OXImportDeclaration/importedFullyQualifiedName"/>
+ </genClasses>
+ </genPackages>
+</genmodel:GenModel>
diff --git a/org.eclipse.osbp.xtext.oxtype/plugin.properties b/org.eclipse.osbp.xtext.oxtype/plugin.properties
new file mode 100644
index 0000000..c5851f4
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/plugin.properties
@@ -0,0 +1,4 @@
+# generated by Xtext 2.11.0.beta2
+
+pluginName = OXtype Model
+providerName = www.example.org
diff --git a/org.eclipse.osbp.xtext.oxtype/plugin.xml b/org.eclipse.osbp.xtext.oxtype/plugin.xml
new file mode 100644
index 0000000..77bf11f
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/plugin.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+<plugin>
+ <extension point="org.eclipse.emf.ecore.generated_package">
+ <!-- @generated OXtype -->
+ <package
+ uri="http://www.eclipse.org/osbp/xtext/oxtype/OXtype"
+ class="org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage"
+ genModel="model/OXtype.genmodel"/>
+ </extension>
+</plugin>
diff --git a/org.eclipse.osbp.xtext.oxtype/pom.xml b/org.eclipse.osbp.xtext.oxtype/pom.xml
new file mode 100644
index 0000000..ac1f1f0
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/pom.xml
@@ -0,0 +1,140 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.eclipse.osbp.xtext.oxtype</groupId>
+ <artifactId>org.eclipse.osbp.xtext.oxtype.aggregator</artifactId>
+ <version>0.9.0-SNAPSHOT</version>
+ <relativePath>..</relativePath>
+ </parent>
+ <artifactId>org.eclipse.osbp.xtext.oxtype</artifactId>
+ <packaging>eclipse-plugin</packaging>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>exec-maven-plugin</artifactId>
+ <version>1.4.0</version>
+ <executions>
+ <execution>
+ <id>mwe2Launcher</id>
+ <phase>generate-sources</phase>
+ <goals>
+ <goal>java</goal>
+ </goals>
+ </execution>
+ </executions>
+ <configuration>
+ <mainClass>org.eclipse.emf.mwe2.launch.runtime.Mwe2Launcher</mainClass>
+ <arguments>
+ <argument>/${project.basedir}/src/org/eclipse/osbp/xtext/oxtype/GenerateOXtype.mwe2</argument>
+ <argument>-p</argument>
+ <argument>rootPath=/${project.basedir}/..</argument>
+ </arguments>
+ <classpathScope>compile</classpathScope>
+ <includePluginDependencies>true</includePluginDependencies>
+ <cleanupDaemonThreads>false</cleanupDaemonThreads><!-- see https://bugs.eclipse.org/bugs/show_bug.cgi?id=475098#c3 -->
+ </configuration>
+ <dependencies>
+ <dependency>
+ <groupId>org.eclipse.emf</groupId>
+ <artifactId>org.eclipse.emf.mwe2.launch</artifactId>
+ <version>2.8.3</version>
+ </dependency>
+ <dependency>
+ <groupId>org.eclipse.xtext</groupId>
+ <artifactId>org.eclipse.xtext.xtext.generator</artifactId>
+ <version>${xtextVersion}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.eclipse.xtext</groupId>
+ <artifactId>org.eclipse.xtext.xbase</artifactId>
+ <version>${xtextVersion}</version>
+ </dependency>
+ </dependencies>
+ </plugin>
+ <plugin>
+ <groupId>org.eclipse.xtend</groupId>
+ <artifactId>xtend-maven-plugin</artifactId>
+ </plugin>
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-clean-plugin</artifactId>
+ <configuration>
+ <filesets combine.children="append">
+ <fileset>
+ <directory>${basedir}/../org.eclipse.osbp.xtext.oxtype/src-gen/</directory>
+ <includes>
+ <include>**/*</include>
+ </includes>
+ </fileset>
+ <fileset>
+ <directory>${basedir}/../org.eclipse.osbp.xtext.oxtype.tests/src-gen/</directory>
+ <includes>
+ <include>**/*</include>
+ </includes>
+ </fileset>
+ <fileset>
+ <directory>${basedir}/../org.eclipse.osbp.xtext.oxtype.ide/src-gen/</directory>
+ <includes>
+ <include>**/*</include>
+ </includes>
+ </fileset>
+ <fileset>
+ <directory>${basedir}/../org.eclipse.osbp.xtext.oxtype.ui/src-gen/</directory>
+ <includes>
+ <include>**/*</include>
+ </includes>
+ </fileset>
+ <fileset>
+ <directory>${basedir}/../org.eclipse.osbp.xtext.oxtype.ui.tests/src-gen/</directory>
+ <includes>
+ <include>**/*</include>
+ </includes>
+ </fileset>
+ <fileset>
+ <directory>${basedir}/model/generated/</directory>
+ </fileset>
+ </filesets>
+ </configuration>
+ </plugin>
+ </plugins>
+ <pluginManagement>
+ <plugins>
+ <plugin>
+ <groupId>org.eclipse.m2e</groupId>
+ <artifactId>lifecycle-mapping</artifactId>
+ <version>1.0.0</version>
+ <configuration>
+ <lifecycleMappingMetadata>
+ <pluginExecutions>
+ <pluginExecution>
+ <pluginExecutionFilter>
+ <groupId>
+ org.codehaus.mojo
+ </groupId>
+ <artifactId>
+ exec-maven-plugin
+ </artifactId>
+ <versionRange>
+ [1.2.1,)
+ </versionRange>
+ <goals>
+ <goal>java</goal>
+ </goals>
+ </pluginExecutionFilter>
+ <action>
+ <ignore></ignore>
+ </action>
+ </pluginExecution>
+ </pluginExecutions>
+ </lifecycleMappingMetadata>
+ </configuration>
+ </plugin>
+ </plugins>
+ </pluginManagement>
+ </build>
+
+</project>
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/AbstractOXtypeRuntimeModule.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/AbstractOXtypeRuntimeModule.java
new file mode 100644
index 0000000..89bb950
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/AbstractOXtypeRuntimeModule.java
@@ -0,0 +1,230 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype;
+
+import com.google.inject.Binder;
+import com.google.inject.Provider;
+import com.google.inject.name.Names;
+import java.util.Properties;
+import org.eclipse.osbp.xtext.oxtype.jvmmodel.OXtypeJvmModelInferrer;
+import org.eclipse.osbp.xtext.oxtype.parser.antlr.OXtypeAntlrTokenFileProvider;
+import org.eclipse.osbp.xtext.oxtype.parser.antlr.OXtypeParser;
+import org.eclipse.osbp.xtext.oxtype.parser.antlr.internal.InternalOXtypeLexer;
+import org.eclipse.osbp.xtext.oxtype.scoping.OXtypeScopeProvider;
+import org.eclipse.osbp.xtext.oxtype.serializer.OXtypeSemanticSequencer;
+import org.eclipse.osbp.xtext.oxtype.serializer.OXtypeSyntacticSequencer;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+import org.eclipse.osbp.xtext.oxtype.validation.OXtypeValidator;
+import org.eclipse.xtext.Constants;
+import org.eclipse.xtext.IGrammarAccess;
+import org.eclipse.xtext.common.types.xtext.TypesAwareDefaultGlobalScopeProvider;
+import org.eclipse.xtext.naming.IQualifiedNameProvider;
+import org.eclipse.xtext.parser.IParser;
+import org.eclipse.xtext.parser.ITokenToStringConverter;
+import org.eclipse.xtext.parser.antlr.AntlrTokenDefProvider;
+import org.eclipse.xtext.parser.antlr.AntlrTokenToStringConverter;
+import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider;
+import org.eclipse.xtext.parser.antlr.ITokenDefProvider;
+import org.eclipse.xtext.parser.antlr.Lexer;
+import org.eclipse.xtext.parser.antlr.LexerBindings;
+import org.eclipse.xtext.parser.antlr.LexerProvider;
+import org.eclipse.xtext.resource.IContainer;
+import org.eclipse.xtext.resource.ILocationInFileProvider;
+import org.eclipse.xtext.resource.IResourceDescriptions;
+import org.eclipse.xtext.resource.containers.IAllContainersState;
+import org.eclipse.xtext.resource.containers.ResourceSetBasedAllContainersStateProvider;
+import org.eclipse.xtext.resource.containers.StateBasedContainerManager;
+import org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider;
+import org.eclipse.xtext.resource.impl.ResourceSetBasedResourceDescriptions;
+import org.eclipse.xtext.scoping.IGlobalScopeProvider;
+import org.eclipse.xtext.scoping.IScopeProvider;
+import org.eclipse.xtext.scoping.IgnoreCaseLinking;
+import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider;
+import org.eclipse.xtext.serializer.ISerializer;
+import org.eclipse.xtext.serializer.impl.Serializer;
+import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
+import org.eclipse.xtext.serializer.sequencer.ISyntacticSequencer;
+import org.eclipse.xtext.service.SingletonBinding;
+import org.eclipse.xtext.validation.IResourceValidator;
+import org.eclipse.xtext.xbase.annotations.DefaultXbaseWithAnnotationsRuntimeModule;
+import org.eclipse.xtext.xbase.annotations.validation.DerivedStateAwareResourceValidator;
+import org.eclipse.xtext.xbase.jvmmodel.IJvmModelInferrer;
+import org.eclipse.xtext.xbase.jvmmodel.JvmLocationInFileProvider;
+import org.eclipse.xtext.xbase.scoping.XImportSectionNamespaceScopeProvider;
+import org.eclipse.xtext.xbase.scoping.XbaseQualifiedNameProvider;
+import org.eclipse.xtext.xbase.scoping.batch.IBatchScopeProvider;
+import org.eclipse.xtext.xbase.typesystem.internal.DefaultBatchTypeResolver;
+import org.eclipse.xtext.xbase.typesystem.internal.DefaultReentrantTypeResolver;
+import org.eclipse.xtext.xbase.typesystem.internal.LogicalContainerAwareBatchTypeResolver;
+import org.eclipse.xtext.xbase.typesystem.internal.LogicalContainerAwareReentrantTypeResolver;
+import org.eclipse.xtext.xbase.validation.FeatureNameValidator;
+import org.eclipse.xtext.xbase.validation.LogicalContainerAwareFeatureNameValidator;
+
+/**
+ * Manual modifications go to {@link OXtypeRuntimeModule}.
+ */
+@SuppressWarnings("all")
+public abstract class AbstractOXtypeRuntimeModule extends DefaultXbaseWithAnnotationsRuntimeModule {
+
+ protected Properties properties = null;
+
+ @Override
+ public void configure(Binder binder) {
+ properties = tryBindProperties(binder, "org/eclipse/osbp/xtext/oxtype/OXtype.properties");
+ super.configure(binder);
+ }
+
+ public void configureLanguageName(Binder binder) {
+ binder.bind(String.class).annotatedWith(Names.named(Constants.LANGUAGE_NAME)).toInstance("org.eclipse.osbp.xtext.oxtype.OXtype");
+ }
+
+ public void configureFileExtensions(Binder binder) {
+ if (properties == null || properties.getProperty(Constants.FILE_EXTENSIONS) == null)
+ binder.bind(String.class).annotatedWith(Names.named(Constants.FILE_EXTENSIONS)).toInstance("oxtype");
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2
+ public ClassLoader bindClassLoaderToInstance() {
+ return getClass().getClassLoader();
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2
+ public Class<? extends IGrammarAccess> bindIGrammarAccess() {
+ return OXtypeGrammarAccess.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2
+ public Class<? extends ISemanticSequencer> bindISemanticSequencer() {
+ return OXtypeSemanticSequencer.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2
+ public Class<? extends ISyntacticSequencer> bindISyntacticSequencer() {
+ return OXtypeSyntacticSequencer.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2
+ public Class<? extends ISerializer> bindISerializer() {
+ return Serializer.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public Class<? extends IParser> bindIParser() {
+ return OXtypeParser.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public Class<? extends ITokenToStringConverter> bindITokenToStringConverter() {
+ return AntlrTokenToStringConverter.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public Class<? extends IAntlrTokenFileProvider> bindIAntlrTokenFileProvider() {
+ return OXtypeAntlrTokenFileProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public Class<? extends Lexer> bindLexer() {
+ return InternalOXtypeLexer.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public Class<? extends ITokenDefProvider> bindITokenDefProvider() {
+ return AntlrTokenDefProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public Provider<? extends InternalOXtypeLexer> provideInternalOXtypeLexer() {
+ return LexerProvider.create(InternalOXtypeLexer.class);
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public void configureRuntimeLexer(Binder binder) {
+ binder.bind(Lexer.class)
+ .annotatedWith(Names.named(LexerBindings.RUNTIME))
+ .to(InternalOXtypeLexer.class);
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2
+ @SingletonBinding(eager=true)
+ public Class<? extends OXtypeValidator> bindOXtypeValidator() {
+ return OXtypeValidator.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2
+ public Class<? extends IBatchScopeProvider> bindIBatchScopeProvider() {
+ return OXtypeScopeProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2
+ public void configureIScopeProviderDelegate(Binder binder) {
+ binder.bind(IScopeProvider.class).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(XImportSectionNamespaceScopeProvider.class);
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2
+ public void configureIgnoreCaseLinking(Binder binder) {
+ binder.bindConstant().annotatedWith(IgnoreCaseLinking.class).to(false);
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+ public Class<? extends IContainer.Manager> bindIContainer$Manager() {
+ return StateBasedContainerManager.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+ public Class<? extends IAllContainersState.Provider> bindIAllContainersState$Provider() {
+ return ResourceSetBasedAllContainersStateProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+ public void configureIResourceDescriptions(Binder binder) {
+ binder.bind(IResourceDescriptions.class).to(ResourceSetBasedResourceDescriptions.class);
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+ public void configureIResourceDescriptionsPersisted(Binder binder) {
+ binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.PERSISTED_DESCRIPTIONS)).to(ResourceSetBasedResourceDescriptions.class);
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends IQualifiedNameProvider> bindIQualifiedNameProvider() {
+ return XbaseQualifiedNameProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends ILocationInFileProvider> bindILocationInFileProvider() {
+ return JvmLocationInFileProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends IGlobalScopeProvider> bindIGlobalScopeProvider() {
+ return TypesAwareDefaultGlobalScopeProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends FeatureNameValidator> bindFeatureNameValidator() {
+ return LogicalContainerAwareFeatureNameValidator.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends DefaultBatchTypeResolver> bindDefaultBatchTypeResolver() {
+ return LogicalContainerAwareBatchTypeResolver.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends DefaultReentrantTypeResolver> bindDefaultReentrantTypeResolver() {
+ return LogicalContainerAwareReentrantTypeResolver.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends IResourceValidator> bindIResourceValidator() {
+ return DerivedStateAwareResourceValidator.class;
+ }
+
+ // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+ public Class<? extends IJvmModelInferrer> bindIJvmModelInferrer() {
+ return OXtypeJvmModelInferrer.class;
+ }
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/OXtypeStandaloneSetupGenerated.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/OXtypeStandaloneSetupGenerated.java
new file mode 100644
index 0000000..25fd405
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/OXtypeStandaloneSetupGenerated.java
@@ -0,0 +1,37 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype;
+
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.xtext.ISetup;
+import org.eclipse.xtext.resource.IResourceFactory;
+import org.eclipse.xtext.resource.IResourceServiceProvider;
+import org.eclipse.xtext.xbase.annotations.XbaseWithAnnotationsStandaloneSetup;
+
+@SuppressWarnings("all")
+public class OXtypeStandaloneSetupGenerated implements ISetup {
+
+ @Override
+ public Injector createInjectorAndDoEMFRegistration() {
+ XbaseWithAnnotationsStandaloneSetup.doSetup();
+
+ Injector injector = createInjector();
+ register(injector);
+ return injector;
+ }
+
+ public Injector createInjector() {
+ return Guice.createInjector(new OXtypeRuntimeModule());
+ }
+
+ public void register(Injector injector) {
+ IResourceFactory resourceFactory = injector.getInstance(IResourceFactory.class);
+ IResourceServiceProvider serviceProvider = injector.getInstance(IResourceServiceProvider.class);
+
+ Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("oxtype", resourceFactory);
+ IResourceServiceProvider.Registry.INSTANCE.getExtensionToFactoryMap().put("oxtype", serviceProvider);
+ }
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/OXtypeAntlrTokenFileProvider.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/OXtypeAntlrTokenFileProvider.java
new file mode 100644
index 0000000..580e022
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/OXtypeAntlrTokenFileProvider.java
@@ -0,0 +1,16 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.parser.antlr;
+
+import java.io.InputStream;
+import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider;
+
+public class OXtypeAntlrTokenFileProvider implements IAntlrTokenFileProvider {
+
+ @Override
+ public InputStream getAntlrTokenFile() {
+ ClassLoader classLoader = getClass().getClassLoader();
+ return classLoader.getResourceAsStream("org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtype.tokens");
+ }
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/OXtypeParser.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/OXtypeParser.java
new file mode 100644
index 0000000..0ace959
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/OXtypeParser.java
@@ -0,0 +1,40 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.parser.antlr;
+
+import com.google.inject.Inject;
+import org.eclipse.osbp.xtext.oxtype.parser.antlr.internal.InternalOXtypeParser;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+import org.eclipse.xtext.parser.antlr.AbstractAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+
+public class OXtypeParser extends AbstractAntlrParser {
+
+ @Inject
+ private OXtypeGrammarAccess grammarAccess;
+
+ @Override
+ protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
+ tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
+ }
+
+
+ @Override
+ protected InternalOXtypeParser createParser(XtextTokenStream stream) {
+ return new InternalOXtypeParser(stream, getGrammarAccess());
+ }
+
+ @Override
+ protected String getDefaultRuleName() {
+ return "XImportDeclaration";
+ }
+
+ public OXtypeGrammarAccess getGrammarAccess() {
+ return this.grammarAccess;
+ }
+
+ public void setGrammarAccess(OXtypeGrammarAccess grammarAccess) {
+ this.grammarAccess = grammarAccess;
+ }
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtype.g b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtype.g
new file mode 100644
index 0000000..d388467
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtype.g
@@ -0,0 +1,6904 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+grammar InternalOXtype;
+
+options {
+ superClass=AbstractInternalAntlrParser;
+}
+
+@lexer::header {
+package org.eclipse.osbp.xtext.oxtype.parser.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.parser.antlr.Lexer;
+}
+
+@parser::header {
+package org.eclipse.osbp.xtext.oxtype.parser.antlr.internal;
+
+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.AbstractInternalAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+
+}
+
+@parser::members {
+
+ private OXtypeGrammarAccess grammarAccess;
+
+ public InternalOXtypeParser(TokenStream input, OXtypeGrammarAccess grammarAccess) {
+ this(input);
+ this.grammarAccess = grammarAccess;
+ registerRules(grammarAccess.getGrammar());
+ }
+
+ @Override
+ protected String getFirstRuleName() {
+ return "XImportDeclaration";
+ }
+
+ @Override
+ protected OXtypeGrammarAccess getGrammarAccess() {
+ return grammarAccess;
+ }
+
+}
+
+@rulecatch {
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+}
+
+// Entry rule entryRuleXImportDeclaration
+entryRuleXImportDeclaration returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXImportDeclarationRule()); }
+ iv_ruleXImportDeclaration=ruleXImportDeclaration
+ { $current=$iv_ruleXImportDeclaration.current; }
+ EOF;
+
+// Rule XImportDeclaration
+ruleXImportDeclaration returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXImportDeclarationAccess().getOXImportDeclarationAction_0(),
+ $current);
+ }
+ )
+ otherlv_1='import'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXImportDeclarationAccess().getImportKeyword_1());
+ }
+ (
+ (
+ (
+ (
+ lv_static_2_0='static'
+ {
+ newLeafNode(lv_static_2_0, grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXImportDeclarationRule());
+ }
+ setWithLastConsumed($current, "static", true, "static");
+ }
+ )
+ )
+ (
+ (
+ lv_extension_3_0='extension'
+ {
+ newLeafNode(lv_extension_3_0, grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXImportDeclarationRule());
+ }
+ setWithLastConsumed($current, "extension", true, "extension");
+ }
+ )
+ )?
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXImportDeclarationRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0());
+ }
+ ruleQualifiedNameInStaticImport
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ (
+ (
+ lv_wildcard_5_0='*'
+ {
+ newLeafNode(lv_wildcard_5_0, grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXImportDeclarationRule());
+ }
+ setWithLastConsumed($current, "wildcard", true, "*");
+ }
+ )
+ )
+ |
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_2_0_3_1_0());
+ }
+ lv_memberName_6_0=ruleValidID
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXImportDeclarationRule());
+ }
+ set(
+ $current,
+ "memberName",
+ lv_memberName_6_0,
+ "org.eclipse.xtext.xbase.Xtype.ValidID");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ )
+ |
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXImportDeclarationRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_1_0());
+ }
+ ruleQualifiedName
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ |
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0());
+ }
+ lv_importedNamespace_8_0=ruleQualifiedNameWithWildcard
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXImportDeclarationRule());
+ }
+ set(
+ $current,
+ "importedNamespace",
+ lv_importedNamespace_8_0,
+ "org.eclipse.xtext.xbase.Xtype.QualifiedNameWithWildcard");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ |
+ (
+ (
+ (
+ lv_fqnImport_9_0='ns'
+ {
+ newLeafNode(lv_fqnImport_9_0, grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXImportDeclarationRule());
+ }
+ setWithLastConsumed($current, "fqnImport", true, "ns");
+ }
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0());
+ }
+ lv_importedFullyQualifiedName_10_0=ruleQualifiedName
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXImportDeclarationRule());
+ }
+ set(
+ $current,
+ "importedFullyQualifiedName",
+ lv_importedFullyQualifiedName_10_0,
+ "org.eclipse.xtext.xbase.Xbase.QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ )
+ (
+ otherlv_11=';'
+ {
+ newLeafNode(otherlv_11, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_3());
+ }
+ )?
+ )
+;
+
+// Entry rule entryRuleXAnnotation
+entryRuleXAnnotation returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXAnnotationRule()); }
+ iv_ruleXAnnotation=ruleXAnnotation
+ { $current=$iv_ruleXAnnotation.current; }
+ EOF;
+
+// Rule XAnnotation
+ruleXAnnotation returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXAnnotationAccess().getXAnnotationAction_0(),
+ $current);
+ }
+ )
+ otherlv_1='@'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXAnnotationAccess().getCommercialAtKeyword_1());
+ }
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXAnnotationRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeCrossReference_2_0());
+ }
+ ruleQualifiedName
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ (
+ ('(')=>
+ otherlv_3='('
+ {
+ newLeafNode(otherlv_3, grammarAccess.getXAnnotationAccess().getLeftParenthesisKeyword_3_0());
+ }
+ )
+ (
+ (
+ (
+ ((
+ (
+ (
+ ruleValidID
+ )
+ )
+ '='
+ )
+ )=>
+ (
+ {
+ newCompositeNode(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_0_0());
+ }
+ lv_elementValuePairs_4_0=ruleXAnnotationElementValuePair
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationRule());
+ }
+ add(
+ $current,
+ "elementValuePairs",
+ lv_elementValuePairs_4_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationElementValuePair");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_5=','
+ {
+ newLeafNode(otherlv_5, grammarAccess.getXAnnotationAccess().getCommaKeyword_3_1_0_1_0());
+ }
+ (
+ ((
+ (
+ (
+ ruleValidID
+ )
+ )
+ '='
+ )
+ )=>
+ (
+ {
+ newCompositeNode(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_1_1_0());
+ }
+ lv_elementValuePairs_6_0=ruleXAnnotationElementValuePair
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationRule());
+ }
+ add(
+ $current,
+ "elementValuePairs",
+ lv_elementValuePairs_6_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationElementValuePair");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )
+ |
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXAnnotationAccess().getValueXAnnotationElementValueOrCommaListParserRuleCall_3_1_1_0());
+ }
+ lv_value_7_0=ruleXAnnotationElementValueOrCommaList
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_7_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationElementValueOrCommaList");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )?
+ otherlv_8=')'
+ {
+ newLeafNode(otherlv_8, grammarAccess.getXAnnotationAccess().getRightParenthesisKeyword_3_2());
+ }
+ )?
+ )
+;
+
+// Entry rule entryRuleXAnnotationElementValuePair
+entryRuleXAnnotationElementValuePair returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXAnnotationElementValuePairRule()); }
+ iv_ruleXAnnotationElementValuePair=ruleXAnnotationElementValuePair
+ { $current=$iv_ruleXAnnotationElementValuePair.current; }
+ EOF;
+
+// Rule XAnnotationElementValuePair
+ruleXAnnotationElementValuePair returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ ((
+ (
+ (
+ ruleValidID
+ )
+ )
+ '='
+ )
+ )=>
+ (
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXAnnotationElementValuePairRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationCrossReference_0_0_0_0());
+ }
+ ruleValidID
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ otherlv_1='='
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXAnnotationElementValuePairAccess().getEqualsSignKeyword_0_0_1());
+ }
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValuePairAccess().getValueXAnnotationElementValueParserRuleCall_1_0());
+ }
+ lv_value_2_0=ruleXAnnotationElementValue
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationElementValuePairRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_2_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationElementValue");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleXAnnotationElementValueOrCommaList
+entryRuleXAnnotationElementValueOrCommaList returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListRule()); }
+ iv_ruleXAnnotationElementValueOrCommaList=ruleXAnnotationElementValueOrCommaList
+ { $current=$iv_ruleXAnnotationElementValueOrCommaList.current; }
+ EOF;
+
+// Rule XAnnotationElementValueOrCommaList
+ruleXAnnotationElementValueOrCommaList returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ (
+ ((
+ (
+ )
+ '#'
+ '['
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralAction_0_0_0_0(),
+ $current);
+ }
+ )
+ otherlv_1='#'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getNumberSignKeyword_0_0_0_1());
+ }
+ otherlv_2='['
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getLeftSquareBracketKeyword_0_0_0_2());
+ }
+ )
+ )
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0());
+ }
+ lv_elements_3_0=ruleXAnnotationOrExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_3_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_4=','
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_0_1_1_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0());
+ }
+ lv_elements_5_0=ruleXAnnotationOrExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_5_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )?
+ otherlv_6=']'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getRightSquareBracketKeyword_0_2());
+ }
+ )
+ |
+ (
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXAnnotationOrExpressionParserRuleCall_1_0());
+ }
+ this_XAnnotationOrExpression_7=ruleXAnnotationOrExpression
+ {
+ $current = $this_XAnnotationOrExpression_7.current;
+ afterParserOrEnumRuleCall();
+ }
+ (
+ (
+ {
+ $current = forceCreateModelElementAndAdd(
+ grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0(),
+ $current);
+ }
+ )
+ (
+ otherlv_9=','
+ {
+ newLeafNode(otherlv_9, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_1_1_1_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_1_1_1_1_0());
+ }
+ lv_elements_10_0=ruleXAnnotationOrExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_10_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )+
+ )?
+ )
+ )
+;
+
+// Entry rule entryRuleXAnnotationElementValue
+entryRuleXAnnotationElementValue returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXAnnotationElementValueRule()); }
+ iv_ruleXAnnotationElementValue=ruleXAnnotationElementValue
+ { $current=$iv_ruleXAnnotationElementValue.current; }
+ EOF;
+
+// Rule XAnnotationElementValue
+ruleXAnnotationElementValue returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ (
+ ((
+ (
+ )
+ '#'
+ '['
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXAnnotationElementValueAccess().getXListLiteralAction_0_0_0_0(),
+ $current);
+ }
+ )
+ otherlv_1='#'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXAnnotationElementValueAccess().getNumberSignKeyword_0_0_0_1());
+ }
+ otherlv_2='['
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXAnnotationElementValueAccess().getLeftSquareBracketKeyword_0_0_0_2());
+ }
+ )
+ )
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0());
+ }
+ lv_elements_3_0=ruleXAnnotationOrExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationElementValueRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_3_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_4=','
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXAnnotationElementValueAccess().getCommaKeyword_0_1_1_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0());
+ }
+ lv_elements_5_0=ruleXAnnotationOrExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationElementValueRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_5_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )?
+ otherlv_6=']'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXAnnotationElementValueAccess().getRightSquareBracketKeyword_0_2());
+ }
+ )
+ |
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1());
+ }
+ this_XAnnotationOrExpression_7=ruleXAnnotationOrExpression
+ {
+ $current = $this_XAnnotationOrExpression_7.current;
+ afterParserOrEnumRuleCall();
+ }
+ )
+;
+
+// Entry rule entryRuleXAnnotationOrExpression
+entryRuleXAnnotationOrExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXAnnotationOrExpressionRule()); }
+ iv_ruleXAnnotationOrExpression=ruleXAnnotationOrExpression
+ { $current=$iv_ruleXAnnotationOrExpression.current; }
+ EOF;
+
+// Rule XAnnotationOrExpression
+ruleXAnnotationOrExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0());
+ }
+ this_XAnnotation_0=ruleXAnnotation
+ {
+ $current = $this_XAnnotation_0.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1());
+ }
+ this_XExpression_1=ruleXExpression
+ {
+ $current = $this_XExpression_1.current;
+ afterParserOrEnumRuleCall();
+ }
+ )
+;
+
+// Entry rule entryRuleXExpression
+entryRuleXExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXExpressionRule()); }
+ iv_ruleXExpression=ruleXExpression
+ { $current=$iv_ruleXExpression.current; }
+ EOF;
+
+// Rule XExpression
+ruleXExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ {
+ newCompositeNode(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall());
+ }
+ this_XAssignment_0=ruleXAssignment
+ {
+ $current = $this_XAssignment_0.current;
+ afterParserOrEnumRuleCall();
+ }
+;
+
+// Entry rule entryRuleXAssignment
+entryRuleXAssignment returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXAssignmentRule()); }
+ iv_ruleXAssignment=ruleXAssignment
+ { $current=$iv_ruleXAssignment.current; }
+ EOF;
+
+// Rule XAssignment
+ruleXAssignment returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0(),
+ $current);
+ }
+ )
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXAssignmentRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0());
+ }
+ ruleFeatureCallID
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ {
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2());
+ }
+ ruleOpSingleAssign
+ {
+ afterParserOrEnumRuleCall();
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0());
+ }
+ lv_value_3_0=ruleXAssignment
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAssignmentRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XAssignment");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ |
+ (
+ {
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0());
+ }
+ this_XOrExpression_4=ruleXOrExpression
+ {
+ $current = $this_XOrExpression_4.current;
+ afterParserOrEnumRuleCall();
+ }
+ (
+ (
+ ((
+ (
+ )
+ (
+ (
+ ruleOpMultiAssign
+ )
+ )
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(),
+ $current);
+ }
+ )
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXAssignmentRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0());
+ }
+ ruleOpMultiAssign
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0());
+ }
+ lv_rightOperand_7_0=ruleXAssignment
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAssignmentRule());
+ }
+ set(
+ $current,
+ "rightOperand",
+ lv_rightOperand_7_0,
+ "org.eclipse.xtext.xbase.Xbase.XAssignment");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )?
+ )
+ )
+;
+
+// Entry rule entryRuleOpSingleAssign
+entryRuleOpSingleAssign returns [String current=null]:
+ { newCompositeNode(grammarAccess.getOpSingleAssignRule()); }
+ iv_ruleOpSingleAssign=ruleOpSingleAssign
+ { $current=$iv_ruleOpSingleAssign.current.getText(); }
+ EOF;
+
+// Rule OpSingleAssign
+ruleOpSingleAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ kw='='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword());
+ }
+;
+
+// Entry rule entryRuleOpMultiAssign
+entryRuleOpMultiAssign returns [String current=null]:
+ { newCompositeNode(grammarAccess.getOpMultiAssignRule()); }
+ iv_ruleOpMultiAssign=ruleOpMultiAssign
+ { $current=$iv_ruleOpMultiAssign.current.getText(); }
+ EOF;
+
+// Rule OpMultiAssign
+ruleOpMultiAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ kw='+='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0());
+ }
+ |
+ kw='-='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1());
+ }
+ |
+ kw='*='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2());
+ }
+ |
+ kw='/='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3());
+ }
+ |
+ kw='%='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4());
+ }
+ |
+ (
+ kw='<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0());
+ }
+ kw='<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1());
+ }
+ kw='='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2());
+ }
+ )
+ |
+ (
+ kw='>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0());
+ }
+ (
+ kw='>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1());
+ }
+ )?
+ kw='>='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2());
+ }
+ )
+ )
+;
+
+// Entry rule entryRuleXOrExpression
+entryRuleXOrExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXOrExpressionRule()); }
+ iv_ruleXOrExpression=ruleXOrExpression
+ { $current=$iv_ruleXOrExpression.current; }
+ EOF;
+
+// Rule XOrExpression
+ruleXOrExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0());
+ }
+ this_XAndExpression_0=ruleXAndExpression
+ {
+ $current = $this_XAndExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+ (
+ (
+ ((
+ (
+ )
+ (
+ (
+ ruleOpOr
+ )
+ )
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ $current);
+ }
+ )
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXOrExpressionRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ ruleOpOr
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0());
+ }
+ lv_rightOperand_3_0=ruleXAndExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXOrExpressionRule());
+ }
+ set(
+ $current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XAndExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )
+;
+
+// Entry rule entryRuleOpOr
+entryRuleOpOr returns [String current=null]:
+ { newCompositeNode(grammarAccess.getOpOrRule()); }
+ iv_ruleOpOr=ruleOpOr
+ { $current=$iv_ruleOpOr.current.getText(); }
+ EOF;
+
+// Rule OpOr
+ruleOpOr returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ kw='||'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword());
+ }
+;
+
+// Entry rule entryRuleXAndExpression
+entryRuleXAndExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXAndExpressionRule()); }
+ iv_ruleXAndExpression=ruleXAndExpression
+ { $current=$iv_ruleXAndExpression.current; }
+ EOF;
+
+// Rule XAndExpression
+ruleXAndExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0());
+ }
+ this_XEqualityExpression_0=ruleXEqualityExpression
+ {
+ $current = $this_XEqualityExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+ (
+ (
+ ((
+ (
+ )
+ (
+ (
+ ruleOpAnd
+ )
+ )
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ $current);
+ }
+ )
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXAndExpressionRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ ruleOpAnd
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0());
+ }
+ lv_rightOperand_3_0=ruleXEqualityExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAndExpressionRule());
+ }
+ set(
+ $current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XEqualityExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )
+;
+
+// Entry rule entryRuleOpAnd
+entryRuleOpAnd returns [String current=null]:
+ { newCompositeNode(grammarAccess.getOpAndRule()); }
+ iv_ruleOpAnd=ruleOpAnd
+ { $current=$iv_ruleOpAnd.current.getText(); }
+ EOF;
+
+// Rule OpAnd
+ruleOpAnd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ kw='&&'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword());
+ }
+;
+
+// Entry rule entryRuleXEqualityExpression
+entryRuleXEqualityExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXEqualityExpressionRule()); }
+ iv_ruleXEqualityExpression=ruleXEqualityExpression
+ { $current=$iv_ruleXEqualityExpression.current; }
+ EOF;
+
+// Rule XEqualityExpression
+ruleXEqualityExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0());
+ }
+ this_XRelationalExpression_0=ruleXRelationalExpression
+ {
+ $current = $this_XRelationalExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+ (
+ (
+ ((
+ (
+ )
+ (
+ (
+ ruleOpEquality
+ )
+ )
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ $current);
+ }
+ )
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXEqualityExpressionRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ ruleOpEquality
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0());
+ }
+ lv_rightOperand_3_0=ruleXRelationalExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXEqualityExpressionRule());
+ }
+ set(
+ $current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XRelationalExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )
+;
+
+// Entry rule entryRuleOpEquality
+entryRuleOpEquality returns [String current=null]:
+ { newCompositeNode(grammarAccess.getOpEqualityRule()); }
+ iv_ruleOpEquality=ruleOpEquality
+ { $current=$iv_ruleOpEquality.current.getText(); }
+ EOF;
+
+// Rule OpEquality
+ruleOpEquality returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ kw='=='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0());
+ }
+ |
+ kw='!='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1());
+ }
+ |
+ kw='==='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2());
+ }
+ |
+ kw='!=='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3());
+ }
+ )
+;
+
+// Entry rule entryRuleXRelationalExpression
+entryRuleXRelationalExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXRelationalExpressionRule()); }
+ iv_ruleXRelationalExpression=ruleXRelationalExpression
+ { $current=$iv_ruleXRelationalExpression.current; }
+ EOF;
+
+// Rule XRelationalExpression
+ruleXRelationalExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0());
+ }
+ this_XOtherOperatorExpression_0=ruleXOtherOperatorExpression
+ {
+ $current = $this_XOtherOperatorExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+ (
+ (
+ (
+ ((
+ (
+ )
+ 'instanceof'
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0(),
+ $current);
+ }
+ )
+ otherlv_2='instanceof'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1());
+ }
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0());
+ }
+ lv_type_3_0=ruleJvmTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule());
+ }
+ set(
+ $current,
+ "type",
+ lv_type_3_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ |
+ (
+ (
+ ((
+ (
+ )
+ (
+ (
+ ruleOpCompare
+ )
+ )
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(),
+ $current);
+ }
+ )
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXRelationalExpressionRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0());
+ }
+ ruleOpCompare
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0());
+ }
+ lv_rightOperand_6_0=ruleXOtherOperatorExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule());
+ }
+ set(
+ $current,
+ "rightOperand",
+ lv_rightOperand_6_0,
+ "org.eclipse.xtext.xbase.Xbase.XOtherOperatorExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ )*
+ )
+;
+
+// Entry rule entryRuleOpCompare
+entryRuleOpCompare returns [String current=null]:
+ { newCompositeNode(grammarAccess.getOpCompareRule()); }
+ iv_ruleOpCompare=ruleOpCompare
+ { $current=$iv_ruleOpCompare.current.getText(); }
+ EOF;
+
+// Rule OpCompare
+ruleOpCompare returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ kw='>='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0());
+ }
+ |
+ (
+ kw='<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0());
+ }
+ kw='='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1());
+ }
+ )
+ |
+ kw='>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2());
+ }
+ |
+ kw='<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3());
+ }
+ )
+;
+
+// Entry rule entryRuleXOtherOperatorExpression
+entryRuleXOtherOperatorExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXOtherOperatorExpressionRule()); }
+ iv_ruleXOtherOperatorExpression=ruleXOtherOperatorExpression
+ { $current=$iv_ruleXOtherOperatorExpression.current; }
+ EOF;
+
+// Rule XOtherOperatorExpression
+ruleXOtherOperatorExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0());
+ }
+ this_XAdditiveExpression_0=ruleXAdditiveExpression
+ {
+ $current = $this_XAdditiveExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+ (
+ (
+ ((
+ (
+ )
+ (
+ (
+ ruleOpOther
+ )
+ )
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ $current);
+ }
+ )
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXOtherOperatorExpressionRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ ruleOpOther
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0());
+ }
+ lv_rightOperand_3_0=ruleXAdditiveExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXOtherOperatorExpressionRule());
+ }
+ set(
+ $current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XAdditiveExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )
+;
+
+// Entry rule entryRuleOpOther
+entryRuleOpOther returns [String current=null]:
+ { newCompositeNode(grammarAccess.getOpOtherRule()); }
+ iv_ruleOpOther=ruleOpOther
+ { $current=$iv_ruleOpOther.current.getText(); }
+ EOF;
+
+// Rule OpOther
+ruleOpOther returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ kw='->'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0());
+ }
+ |
+ kw='..<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1());
+ }
+ |
+ (
+ kw='>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0());
+ }
+ kw='..'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1());
+ }
+ )
+ |
+ kw='..'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3());
+ }
+ |
+ kw='=>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4());
+ }
+ |
+ (
+ kw='>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0());
+ }
+ (
+ (
+ ((
+ '>'
+ '>'
+ )
+ )=>
+ (
+ kw='>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0());
+ }
+ kw='>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1());
+ }
+ )
+ )
+ |
+ kw='>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1());
+ }
+ )
+ )
+ |
+ (
+ kw='<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0());
+ }
+ (
+ (
+ ((
+ '<'
+ '<'
+ )
+ )=>
+ (
+ kw='<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0());
+ }
+ kw='<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1());
+ }
+ )
+ )
+ |
+ kw='<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1());
+ }
+ |
+ kw='=>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2());
+ }
+ )
+ )
+ |
+ kw='<>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7());
+ }
+ |
+ kw='?:'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8());
+ }
+ )
+;
+
+// Entry rule entryRuleXAdditiveExpression
+entryRuleXAdditiveExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXAdditiveExpressionRule()); }
+ iv_ruleXAdditiveExpression=ruleXAdditiveExpression
+ { $current=$iv_ruleXAdditiveExpression.current; }
+ EOF;
+
+// Rule XAdditiveExpression
+ruleXAdditiveExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0());
+ }
+ this_XMultiplicativeExpression_0=ruleXMultiplicativeExpression
+ {
+ $current = $this_XMultiplicativeExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+ (
+ (
+ ((
+ (
+ )
+ (
+ (
+ ruleOpAdd
+ )
+ )
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ $current);
+ }
+ )
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXAdditiveExpressionRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ ruleOpAdd
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0());
+ }
+ lv_rightOperand_3_0=ruleXMultiplicativeExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAdditiveExpressionRule());
+ }
+ set(
+ $current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XMultiplicativeExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )
+;
+
+// Entry rule entryRuleOpAdd
+entryRuleOpAdd returns [String current=null]:
+ { newCompositeNode(grammarAccess.getOpAddRule()); }
+ iv_ruleOpAdd=ruleOpAdd
+ { $current=$iv_ruleOpAdd.current.getText(); }
+ EOF;
+
+// Rule OpAdd
+ruleOpAdd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ kw='+'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpAddAccess().getPlusSignKeyword_0());
+ }
+ |
+ kw='-'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1());
+ }
+ )
+;
+
+// Entry rule entryRuleXMultiplicativeExpression
+entryRuleXMultiplicativeExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXMultiplicativeExpressionRule()); }
+ iv_ruleXMultiplicativeExpression=ruleXMultiplicativeExpression
+ { $current=$iv_ruleXMultiplicativeExpression.current; }
+ EOF;
+
+// Rule XMultiplicativeExpression
+ruleXMultiplicativeExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0());
+ }
+ this_XUnaryOperation_0=ruleXUnaryOperation
+ {
+ $current = $this_XUnaryOperation_0.current;
+ afterParserOrEnumRuleCall();
+ }
+ (
+ (
+ ((
+ (
+ )
+ (
+ (
+ ruleOpMulti
+ )
+ )
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ $current);
+ }
+ )
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXMultiplicativeExpressionRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ ruleOpMulti
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0());
+ }
+ lv_rightOperand_3_0=ruleXUnaryOperation
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXMultiplicativeExpressionRule());
+ }
+ set(
+ $current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XUnaryOperation");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )
+;
+
+// Entry rule entryRuleOpMulti
+entryRuleOpMulti returns [String current=null]:
+ { newCompositeNode(grammarAccess.getOpMultiRule()); }
+ iv_ruleOpMulti=ruleOpMulti
+ { $current=$iv_ruleOpMulti.current.getText(); }
+ EOF;
+
+// Rule OpMulti
+ruleOpMulti returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ kw='*'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskKeyword_0());
+ }
+ |
+ kw='**'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1());
+ }
+ |
+ kw='/'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAccess().getSolidusKeyword_2());
+ }
+ |
+ kw='%'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAccess().getPercentSignKeyword_3());
+ }
+ )
+;
+
+// Entry rule entryRuleXUnaryOperation
+entryRuleXUnaryOperation returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXUnaryOperationRule()); }
+ iv_ruleXUnaryOperation=ruleXUnaryOperation
+ { $current=$iv_ruleXUnaryOperation.current; }
+ EOF;
+
+// Rule XUnaryOperation
+ruleXUnaryOperation returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0(),
+ $current);
+ }
+ )
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXUnaryOperationRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0());
+ }
+ ruleOpUnary
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0());
+ }
+ lv_operand_2_0=ruleXUnaryOperation
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXUnaryOperationRule());
+ }
+ set(
+ $current,
+ "operand",
+ lv_operand_2_0,
+ "org.eclipse.xtext.xbase.Xbase.XUnaryOperation");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ |
+ {
+ newCompositeNode(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1());
+ }
+ this_XCastedExpression_3=ruleXCastedExpression
+ {
+ $current = $this_XCastedExpression_3.current;
+ afterParserOrEnumRuleCall();
+ }
+ )
+;
+
+// Entry rule entryRuleOpUnary
+entryRuleOpUnary returns [String current=null]:
+ { newCompositeNode(grammarAccess.getOpUnaryRule()); }
+ iv_ruleOpUnary=ruleOpUnary
+ { $current=$iv_ruleOpUnary.current.getText(); }
+ EOF;
+
+// Rule OpUnary
+ruleOpUnary returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ kw='!'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0());
+ }
+ |
+ kw='-'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1());
+ }
+ |
+ kw='+'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2());
+ }
+ )
+;
+
+// Entry rule entryRuleXCastedExpression
+entryRuleXCastedExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXCastedExpressionRule()); }
+ iv_ruleXCastedExpression=ruleXCastedExpression
+ { $current=$iv_ruleXCastedExpression.current; }
+ EOF;
+
+// Rule XCastedExpression
+ruleXCastedExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0());
+ }
+ this_XPostfixOperation_0=ruleXPostfixOperation
+ {
+ $current = $this_XPostfixOperation_0.current;
+ afterParserOrEnumRuleCall();
+ }
+ (
+ (
+ ((
+ (
+ )
+ 'as'
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0(),
+ $current);
+ }
+ )
+ otherlv_2='as'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1());
+ }
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0());
+ }
+ lv_type_3_0=ruleJvmTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXCastedExpressionRule());
+ }
+ set(
+ $current,
+ "type",
+ lv_type_3_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )
+;
+
+// Entry rule entryRuleXPostfixOperation
+entryRuleXPostfixOperation returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXPostfixOperationRule()); }
+ iv_ruleXPostfixOperation=ruleXPostfixOperation
+ { $current=$iv_ruleXPostfixOperation.current; }
+ EOF;
+
+// Rule XPostfixOperation
+ruleXPostfixOperation returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0());
+ }
+ this_XMemberFeatureCall_0=ruleXMemberFeatureCall
+ {
+ $current = $this_XMemberFeatureCall_0.current;
+ afterParserOrEnumRuleCall();
+ }
+ (
+ ((
+ (
+ )
+ (
+ (
+ ruleOpPostfix
+ )
+ )
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0(),
+ $current);
+ }
+ )
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXPostfixOperationRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0());
+ }
+ ruleOpPostfix
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ )?
+ )
+;
+
+// Entry rule entryRuleOpPostfix
+entryRuleOpPostfix returns [String current=null]:
+ { newCompositeNode(grammarAccess.getOpPostfixRule()); }
+ iv_ruleOpPostfix=ruleOpPostfix
+ { $current=$iv_ruleOpPostfix.current.getText(); }
+ EOF;
+
+// Rule OpPostfix
+ruleOpPostfix returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ kw='++'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0());
+ }
+ |
+ kw='--'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1());
+ }
+ )
+;
+
+// Entry rule entryRuleXMemberFeatureCall
+entryRuleXMemberFeatureCall returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXMemberFeatureCallRule()); }
+ iv_ruleXMemberFeatureCall=ruleXMemberFeatureCall
+ { $current=$iv_ruleXMemberFeatureCall.current; }
+ EOF;
+
+// Rule XMemberFeatureCall
+ruleXMemberFeatureCall returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0());
+ }
+ this_XPrimaryExpression_0=ruleXPrimaryExpression
+ {
+ $current = $this_XPrimaryExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+ (
+ (
+ (
+ ((
+ (
+ )
+ (
+ '.'
+ |
+ (
+ (
+ '::'
+ )
+ )
+ )
+ (
+ (
+ ruleFeatureCallID
+ )
+ )
+ ruleOpSingleAssign
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0(),
+ $current);
+ }
+ )
+ (
+ otherlv_2='.'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0());
+ }
+ |
+ (
+ (
+ lv_explicitStatic_3_0='::'
+ {
+ newLeafNode(lv_explicitStatic_3_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+ setWithLastConsumed($current, "explicitStatic", true, "::");
+ }
+ )
+ )
+ )
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0());
+ }
+ ruleFeatureCallID
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3());
+ }
+ ruleOpSingleAssign
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0());
+ }
+ lv_value_6_0=ruleXAssignment
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_6_0,
+ "org.eclipse.xtext.xbase.Xbase.XAssignment");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ |
+ (
+ (
+ ((
+ (
+ )
+ (
+ '.'
+ |
+ (
+ (
+ '?.'
+ )
+ )
+ |
+ (
+ (
+ '::'
+ )
+ )
+ )
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0(),
+ $current);
+ }
+ )
+ (
+ otherlv_8='.'
+ {
+ newLeafNode(otherlv_8, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0());
+ }
+ |
+ (
+ (
+ lv_nullSafe_9_0='?.'
+ {
+ newLeafNode(lv_nullSafe_9_0, grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+ setWithLastConsumed($current, "nullSafe", true, "?.");
+ }
+ )
+ )
+ |
+ (
+ (
+ lv_explicitStatic_10_0='::'
+ {
+ newLeafNode(lv_explicitStatic_10_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+ setWithLastConsumed($current, "explicitStatic", true, "::");
+ }
+ )
+ )
+ )
+ )
+ )
+ (
+ otherlv_11='<'
+ {
+ newLeafNode(otherlv_11, grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0());
+ }
+ lv_typeArguments_12_0=ruleJvmArgumentTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ $current,
+ "typeArguments",
+ lv_typeArguments_12_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_13=','
+ {
+ newLeafNode(otherlv_13, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0());
+ }
+ lv_typeArguments_14_0=ruleJvmArgumentTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ $current,
+ "typeArguments",
+ lv_typeArguments_14_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ otherlv_15='>'
+ {
+ newLeafNode(otherlv_15, grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3());
+ }
+ )?
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0());
+ }
+ ruleIdOrSuper
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ (
+ ((
+ '('
+ )
+ )=>
+ (
+ lv_explicitOperationCall_17_0='('
+ {
+ newLeafNode(lv_explicitOperationCall_17_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+ setWithLastConsumed($current, "explicitOperationCall", true, "(");
+ }
+ )
+ )
+ (
+ (
+ ((
+ (
+ )
+ (
+ (
+ (
+ ruleJvmFormalParameter
+ )
+ )
+ (
+ ','
+ (
+ (
+ ruleJvmFormalParameter
+ )
+ )
+ )*
+ )?
+ (
+ (
+ '|'
+ )
+ )
+ )
+ )=>
+ (
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0());
+ }
+ lv_memberCallArguments_18_0=ruleXShortClosure
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ $current,
+ "memberCallArguments",
+ lv_memberCallArguments_18_0,
+ "org.eclipse.xtext.xbase.Xbase.XShortClosure");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ |
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0());
+ }
+ lv_memberCallArguments_19_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ $current,
+ "memberCallArguments",
+ lv_memberCallArguments_19_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_20=','
+ {
+ newLeafNode(otherlv_20, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0());
+ }
+ lv_memberCallArguments_21_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ $current,
+ "memberCallArguments",
+ lv_memberCallArguments_21_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )
+ )?
+ otherlv_22=')'
+ {
+ newLeafNode(otherlv_22, grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2());
+ }
+ )?
+ (
+ ((
+ (
+ )
+ '['
+ )
+ )=>
+ (
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0());
+ }
+ lv_memberCallArguments_23_0=ruleXClosure
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ $current,
+ "memberCallArguments",
+ lv_memberCallArguments_23_0,
+ "org.eclipse.xtext.xbase.Xbase.XClosure");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )?
+ )
+ )*
+ )
+;
+
+// Entry rule entryRuleXPrimaryExpression
+entryRuleXPrimaryExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXPrimaryExpressionRule()); }
+ iv_ruleXPrimaryExpression=ruleXPrimaryExpression
+ { $current=$iv_ruleXPrimaryExpression.current; }
+ EOF;
+
+// Rule XPrimaryExpression
+ruleXPrimaryExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0());
+ }
+ this_XConstructorCall_0=ruleXConstructorCall
+ {
+ $current = $this_XConstructorCall_0.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1());
+ }
+ this_XBlockExpression_1=ruleXBlockExpression
+ {
+ $current = $this_XBlockExpression_1.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2());
+ }
+ this_XSwitchExpression_2=ruleXSwitchExpression
+ {
+ $current = $this_XSwitchExpression_2.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ (
+ ((
+ (
+ )
+ 'synchronized'
+ '('
+ )
+ )=>
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3());
+ }
+ this_XSynchronizedExpression_3=ruleXSynchronizedExpression
+ {
+ $current = $this_XSynchronizedExpression_3.current;
+ afterParserOrEnumRuleCall();
+ }
+ )
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4());
+ }
+ this_XFeatureCall_4=ruleXFeatureCall
+ {
+ $current = $this_XFeatureCall_4.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5());
+ }
+ this_XLiteral_5=ruleXLiteral
+ {
+ $current = $this_XLiteral_5.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6());
+ }
+ this_XIfExpression_6=ruleXIfExpression
+ {
+ $current = $this_XIfExpression_6.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ (
+ ((
+ (
+ )
+ 'for'
+ '('
+ (
+ (
+ ruleJvmFormalParameter
+ )
+ )
+ ':'
+ )
+ )=>
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7());
+ }
+ this_XForLoopExpression_7=ruleXForLoopExpression
+ {
+ $current = $this_XForLoopExpression_7.current;
+ afterParserOrEnumRuleCall();
+ }
+ )
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8());
+ }
+ this_XBasicForLoopExpression_8=ruleXBasicForLoopExpression
+ {
+ $current = $this_XBasicForLoopExpression_8.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9());
+ }
+ this_XWhileExpression_9=ruleXWhileExpression
+ {
+ $current = $this_XWhileExpression_9.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10());
+ }
+ this_XDoWhileExpression_10=ruleXDoWhileExpression
+ {
+ $current = $this_XDoWhileExpression_10.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11());
+ }
+ this_XThrowExpression_11=ruleXThrowExpression
+ {
+ $current = $this_XThrowExpression_11.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12());
+ }
+ this_XReturnExpression_12=ruleXReturnExpression
+ {
+ $current = $this_XReturnExpression_12.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13());
+ }
+ this_XTryCatchFinallyExpression_13=ruleXTryCatchFinallyExpression
+ {
+ $current = $this_XTryCatchFinallyExpression_13.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14());
+ }
+ this_XParenthesizedExpression_14=ruleXParenthesizedExpression
+ {
+ $current = $this_XParenthesizedExpression_14.current;
+ afterParserOrEnumRuleCall();
+ }
+ )
+;
+
+// Entry rule entryRuleXLiteral
+entryRuleXLiteral returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXLiteralRule()); }
+ iv_ruleXLiteral=ruleXLiteral
+ { $current=$iv_ruleXLiteral.current; }
+ EOF;
+
+// Rule XLiteral
+ruleXLiteral returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0());
+ }
+ this_XCollectionLiteral_0=ruleXCollectionLiteral
+ {
+ $current = $this_XCollectionLiteral_0.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ (
+ ((
+ (
+ )
+ '['
+ )
+ )=>
+ {
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1());
+ }
+ this_XClosure_1=ruleXClosure
+ {
+ $current = $this_XClosure_1.current;
+ afterParserOrEnumRuleCall();
+ }
+ )
+ |
+ {
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2());
+ }
+ this_XBooleanLiteral_2=ruleXBooleanLiteral
+ {
+ $current = $this_XBooleanLiteral_2.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3());
+ }
+ this_XNumberLiteral_3=ruleXNumberLiteral
+ {
+ $current = $this_XNumberLiteral_3.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4());
+ }
+ this_XNullLiteral_4=ruleXNullLiteral
+ {
+ $current = $this_XNullLiteral_4.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5());
+ }
+ this_XStringLiteral_5=ruleXStringLiteral
+ {
+ $current = $this_XStringLiteral_5.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6());
+ }
+ this_XTypeLiteral_6=ruleXTypeLiteral
+ {
+ $current = $this_XTypeLiteral_6.current;
+ afterParserOrEnumRuleCall();
+ }
+ )
+;
+
+// Entry rule entryRuleXCollectionLiteral
+entryRuleXCollectionLiteral returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXCollectionLiteralRule()); }
+ iv_ruleXCollectionLiteral=ruleXCollectionLiteral
+ { $current=$iv_ruleXCollectionLiteral.current; }
+ EOF;
+
+// Rule XCollectionLiteral
+ruleXCollectionLiteral returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0());
+ }
+ this_XSetLiteral_0=ruleXSetLiteral
+ {
+ $current = $this_XSetLiteral_0.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1());
+ }
+ this_XListLiteral_1=ruleXListLiteral
+ {
+ $current = $this_XListLiteral_1.current;
+ afterParserOrEnumRuleCall();
+ }
+ )
+;
+
+// Entry rule entryRuleXSetLiteral
+entryRuleXSetLiteral returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXSetLiteralRule()); }
+ iv_ruleXSetLiteral=ruleXSetLiteral
+ { $current=$iv_ruleXSetLiteral.current; }
+ EOF;
+
+// Rule XSetLiteral
+ruleXSetLiteral returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0(),
+ $current);
+ }
+ )
+ otherlv_1='#'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1());
+ }
+ otherlv_2='{'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2());
+ }
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0());
+ }
+ lv_elements_3_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSetLiteralRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_4=','
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0());
+ }
+ lv_elements_5_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSetLiteralRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )?
+ otherlv_6='}'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4());
+ }
+ )
+;
+
+// Entry rule entryRuleXListLiteral
+entryRuleXListLiteral returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXListLiteralRule()); }
+ iv_ruleXListLiteral=ruleXListLiteral
+ { $current=$iv_ruleXListLiteral.current; }
+ EOF;
+
+// Rule XListLiteral
+ruleXListLiteral returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXListLiteralAccess().getXListLiteralAction_0(),
+ $current);
+ }
+ )
+ otherlv_1='#'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1());
+ }
+ otherlv_2='['
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2());
+ }
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0());
+ }
+ lv_elements_3_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXListLiteralRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_4=','
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0());
+ }
+ lv_elements_5_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXListLiteralRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )?
+ otherlv_6=']'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4());
+ }
+ )
+;
+
+// Entry rule entryRuleXClosure
+entryRuleXClosure returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXClosureRule()); }
+ iv_ruleXClosure=ruleXClosure
+ { $current=$iv_ruleXClosure.current; }
+ EOF;
+
+// Rule XClosure
+ruleXClosure returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ ((
+ (
+ )
+ '['
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXClosureAccess().getXClosureAction_0_0_0(),
+ $current);
+ }
+ )
+ otherlv_1='['
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1());
+ }
+ )
+ )
+ (
+ ((
+ (
+ (
+ (
+ ruleJvmFormalParameter
+ )
+ )
+ (
+ ','
+ (
+ (
+ ruleJvmFormalParameter
+ )
+ )
+ )*
+ )?
+ (
+ (
+ '|'
+ )
+ )
+ )
+ )=>
+ (
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0());
+ }
+ lv_declaredFormalParameters_2_0=ruleJvmFormalParameter
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXClosureRule());
+ }
+ add(
+ $current,
+ "declaredFormalParameters",
+ lv_declaredFormalParameters_2_0,
+ "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_3=','
+ {
+ newLeafNode(otherlv_3, grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0());
+ }
+ lv_declaredFormalParameters_4_0=ruleJvmFormalParameter
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXClosureRule());
+ }
+ add(
+ $current,
+ "declaredFormalParameters",
+ lv_declaredFormalParameters_4_0,
+ "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )?
+ (
+ (
+ lv_explicitSyntax_5_0='|'
+ {
+ newLeafNode(lv_explicitSyntax_5_0, grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXClosureRule());
+ }
+ setWithLastConsumed($current, "explicitSyntax", true, "|");
+ }
+ )
+ )
+ )
+ )?
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0());
+ }
+ lv_expression_6_0=ruleXExpressionInClosure
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXClosureRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_6_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpressionInClosure");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ otherlv_7=']'
+ {
+ newLeafNode(otherlv_7, grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3());
+ }
+ )
+;
+
+// Entry rule entryRuleXExpressionInClosure
+entryRuleXExpressionInClosure returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXExpressionInClosureRule()); }
+ iv_ruleXExpressionInClosure=ruleXExpressionInClosure
+ { $current=$iv_ruleXExpressionInClosure.current; }
+ EOF;
+
+// Rule XExpressionInClosure
+ruleXExpressionInClosure returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0(),
+ $current);
+ }
+ )
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0());
+ }
+ lv_expressions_1_0=ruleXExpressionOrVarDeclaration
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXExpressionInClosureRule());
+ }
+ add(
+ $current,
+ "expressions",
+ lv_expressions_1_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_2=';'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1());
+ }
+ )?
+ )*
+ )
+;
+
+// Entry rule entryRuleXShortClosure
+entryRuleXShortClosure returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXShortClosureRule()); }
+ iv_ruleXShortClosure=ruleXShortClosure
+ { $current=$iv_ruleXShortClosure.current; }
+ EOF;
+
+// Rule XShortClosure
+ruleXShortClosure returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ ((
+ (
+ )
+ (
+ (
+ (
+ ruleJvmFormalParameter
+ )
+ )
+ (
+ ','
+ (
+ (
+ ruleJvmFormalParameter
+ )
+ )
+ )*
+ )?
+ (
+ (
+ '|'
+ )
+ )
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0(),
+ $current);
+ }
+ )
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0());
+ }
+ lv_declaredFormalParameters_1_0=ruleJvmFormalParameter
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXShortClosureRule());
+ }
+ add(
+ $current,
+ "declaredFormalParameters",
+ lv_declaredFormalParameters_1_0,
+ "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_2=','
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0());
+ }
+ lv_declaredFormalParameters_3_0=ruleJvmFormalParameter
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXShortClosureRule());
+ }
+ add(
+ $current,
+ "declaredFormalParameters",
+ lv_declaredFormalParameters_3_0,
+ "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )?
+ (
+ (
+ lv_explicitSyntax_4_0='|'
+ {
+ newLeafNode(lv_explicitSyntax_4_0, grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXShortClosureRule());
+ }
+ setWithLastConsumed($current, "explicitSyntax", true, "|");
+ }
+ )
+ )
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0());
+ }
+ lv_expression_5_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXShortClosureRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleXParenthesizedExpression
+entryRuleXParenthesizedExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXParenthesizedExpressionRule()); }
+ iv_ruleXParenthesizedExpression=ruleXParenthesizedExpression
+ { $current=$iv_ruleXParenthesizedExpression.current; }
+ EOF;
+
+// Rule XParenthesizedExpression
+ruleXParenthesizedExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ otherlv_0='('
+ {
+ newLeafNode(otherlv_0, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0());
+ }
+ {
+ newCompositeNode(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1());
+ }
+ this_XExpression_1=ruleXExpression
+ {
+ $current = $this_XExpression_1.current;
+ afterParserOrEnumRuleCall();
+ }
+ otherlv_2=')'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2());
+ }
+ )
+;
+
+// Entry rule entryRuleXIfExpression
+entryRuleXIfExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXIfExpressionRule()); }
+ iv_ruleXIfExpression=ruleXIfExpression
+ { $current=$iv_ruleXIfExpression.current; }
+ EOF;
+
+// Rule XIfExpression
+ruleXIfExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0(),
+ $current);
+ }
+ )
+ otherlv_1='if'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXIfExpressionAccess().getIfKeyword_1());
+ }
+ otherlv_2='('
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0());
+ }
+ lv_if_3_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXIfExpressionRule());
+ }
+ set(
+ $current,
+ "if",
+ lv_if_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ otherlv_4=')'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0());
+ }
+ lv_then_5_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXIfExpressionRule());
+ }
+ set(
+ $current,
+ "then",
+ lv_then_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ (
+ ('else')=>
+ otherlv_6='else'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0());
+ }
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0());
+ }
+ lv_else_7_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXIfExpressionRule());
+ }
+ set(
+ $current,
+ "else",
+ lv_else_7_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )?
+ )
+;
+
+// Entry rule entryRuleXSwitchExpression
+entryRuleXSwitchExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXSwitchExpressionRule()); }
+ iv_ruleXSwitchExpression=ruleXSwitchExpression
+ { $current=$iv_ruleXSwitchExpression.current; }
+ EOF;
+
+// Rule XSwitchExpression
+ruleXSwitchExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0(),
+ $current);
+ }
+ )
+ otherlv_1='switch'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1());
+ }
+ (
+ (
+ (
+ ((
+ '('
+ (
+ (
+ ruleJvmFormalParameter
+ )
+ )
+ ':'
+ )
+ )=>
+ (
+ otherlv_2='('
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0());
+ }
+ lv_declaredParam_3_0=ruleJvmFormalParameter
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ set(
+ $current,
+ "declaredParam",
+ lv_declaredParam_3_0,
+ "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ otherlv_4=':'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2());
+ }
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0());
+ }
+ lv_switch_5_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ set(
+ $current,
+ "switch",
+ lv_switch_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ otherlv_6=')'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2());
+ }
+ )
+ |
+ (
+ (
+ ((
+ (
+ (
+ ruleJvmFormalParameter
+ )
+ )
+ ':'
+ )
+ )=>
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0());
+ }
+ lv_declaredParam_7_0=ruleJvmFormalParameter
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ set(
+ $current,
+ "declaredParam",
+ lv_declaredParam_7_0,
+ "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ otherlv_8=':'
+ {
+ newLeafNode(otherlv_8, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1());
+ }
+ )
+ )?
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0());
+ }
+ lv_switch_9_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ set(
+ $current,
+ "switch",
+ lv_switch_9_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ )
+ otherlv_10='{'
+ {
+ newLeafNode(otherlv_10, grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0());
+ }
+ lv_cases_11_0=ruleXCasePart
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ add(
+ $current,
+ "cases",
+ lv_cases_11_0,
+ "org.eclipse.xtext.xbase.Xbase.XCasePart");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )*
+ (
+ otherlv_12='default'
+ {
+ newLeafNode(otherlv_12, grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0());
+ }
+ otherlv_13=':'
+ {
+ newLeafNode(otherlv_13, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0());
+ }
+ lv_default_14_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ set(
+ $current,
+ "default",
+ lv_default_14_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )?
+ otherlv_15='}'
+ {
+ newLeafNode(otherlv_15, grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6());
+ }
+ )
+;
+
+// Entry rule entryRuleXCasePart
+entryRuleXCasePart returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXCasePartRule()); }
+ iv_ruleXCasePart=ruleXCasePart
+ { $current=$iv_ruleXCasePart.current; }
+ EOF;
+
+// Rule XCasePart
+ruleXCasePart returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXCasePartAccess().getXCasePartAction_0(),
+ $current);
+ }
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0());
+ }
+ lv_typeGuard_1_0=ruleJvmTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXCasePartRule());
+ }
+ set(
+ $current,
+ "typeGuard",
+ lv_typeGuard_1_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )?
+ (
+ otherlv_2='case'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXCasePartAccess().getCaseKeyword_2_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0());
+ }
+ lv_case_3_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXCasePartRule());
+ }
+ set(
+ $current,
+ "case",
+ lv_case_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )?
+ (
+ (
+ otherlv_4=':'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0());
+ }
+ lv_then_5_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXCasePartRule());
+ }
+ set(
+ $current,
+ "then",
+ lv_then_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ |
+ (
+ (
+ lv_fallThrough_6_0=','
+ {
+ newLeafNode(lv_fallThrough_6_0, grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXCasePartRule());
+ }
+ setWithLastConsumed($current, "fallThrough", true, ",");
+ }
+ )
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleXForLoopExpression
+entryRuleXForLoopExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXForLoopExpressionRule()); }
+ iv_ruleXForLoopExpression=ruleXForLoopExpression
+ { $current=$iv_ruleXForLoopExpression.current; }
+ EOF;
+
+// Rule XForLoopExpression
+ruleXForLoopExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ ((
+ (
+ )
+ 'for'
+ '('
+ (
+ (
+ ruleJvmFormalParameter
+ )
+ )
+ ':'
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0(),
+ $current);
+ }
+ )
+ otherlv_1='for'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1());
+ }
+ otherlv_2='('
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0());
+ }
+ lv_declaredParam_3_0=ruleJvmFormalParameter
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule());
+ }
+ set(
+ $current,
+ "declaredParam",
+ lv_declaredParam_3_0,
+ "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ otherlv_4=':'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4());
+ }
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0());
+ }
+ lv_forExpression_5_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule());
+ }
+ set(
+ $current,
+ "forExpression",
+ lv_forExpression_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ otherlv_6=')'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0());
+ }
+ lv_eachExpression_7_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule());
+ }
+ set(
+ $current,
+ "eachExpression",
+ lv_eachExpression_7_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleXBasicForLoopExpression
+entryRuleXBasicForLoopExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXBasicForLoopExpressionRule()); }
+ iv_ruleXBasicForLoopExpression=ruleXBasicForLoopExpression
+ { $current=$iv_ruleXBasicForLoopExpression.current; }
+ EOF;
+
+// Rule XBasicForLoopExpression
+ruleXBasicForLoopExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0(),
+ $current);
+ }
+ )
+ otherlv_1='for'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1());
+ }
+ otherlv_2='('
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2());
+ }
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0());
+ }
+ lv_initExpressions_3_0=ruleXExpressionOrVarDeclaration
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ add(
+ $current,
+ "initExpressions",
+ lv_initExpressions_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_4=','
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0());
+ }
+ lv_initExpressions_5_0=ruleXExpressionOrVarDeclaration
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ add(
+ $current,
+ "initExpressions",
+ lv_initExpressions_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )?
+ otherlv_6=';'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0());
+ }
+ lv_expression_7_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_7_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )?
+ otherlv_8=';'
+ {
+ newLeafNode(otherlv_8, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6());
+ }
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0());
+ }
+ lv_updateExpressions_9_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ add(
+ $current,
+ "updateExpressions",
+ lv_updateExpressions_9_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_10=','
+ {
+ newLeafNode(otherlv_10, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0());
+ }
+ lv_updateExpressions_11_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ add(
+ $current,
+ "updateExpressions",
+ lv_updateExpressions_11_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )?
+ otherlv_12=')'
+ {
+ newLeafNode(otherlv_12, grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0());
+ }
+ lv_eachExpression_13_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ set(
+ $current,
+ "eachExpression",
+ lv_eachExpression_13_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleXWhileExpression
+entryRuleXWhileExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXWhileExpressionRule()); }
+ iv_ruleXWhileExpression=ruleXWhileExpression
+ { $current=$iv_ruleXWhileExpression.current; }
+ EOF;
+
+// Rule XWhileExpression
+ruleXWhileExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0(),
+ $current);
+ }
+ )
+ otherlv_1='while'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1());
+ }
+ otherlv_2='('
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0());
+ }
+ lv_predicate_3_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXWhileExpressionRule());
+ }
+ set(
+ $current,
+ "predicate",
+ lv_predicate_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ otherlv_4=')'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0());
+ }
+ lv_body_5_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXWhileExpressionRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleXDoWhileExpression
+entryRuleXDoWhileExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXDoWhileExpressionRule()); }
+ iv_ruleXDoWhileExpression=ruleXDoWhileExpression
+ { $current=$iv_ruleXDoWhileExpression.current; }
+ EOF;
+
+// Rule XDoWhileExpression
+ruleXDoWhileExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0(),
+ $current);
+ }
+ )
+ otherlv_1='do'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0());
+ }
+ lv_body_2_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_2_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ otherlv_3='while'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3());
+ }
+ otherlv_4='('
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0());
+ }
+ lv_predicate_5_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule());
+ }
+ set(
+ $current,
+ "predicate",
+ lv_predicate_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ otherlv_6=')'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6());
+ }
+ )
+;
+
+// Entry rule entryRuleXBlockExpression
+entryRuleXBlockExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXBlockExpressionRule()); }
+ iv_ruleXBlockExpression=ruleXBlockExpression
+ { $current=$iv_ruleXBlockExpression.current; }
+ EOF;
+
+// Rule XBlockExpression
+ruleXBlockExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0(),
+ $current);
+ }
+ )
+ otherlv_1='{'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1());
+ }
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0());
+ }
+ lv_expressions_2_0=ruleXExpressionOrVarDeclaration
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXBlockExpressionRule());
+ }
+ add(
+ $current,
+ "expressions",
+ lv_expressions_2_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_3=';'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1());
+ }
+ )?
+ )*
+ otherlv_4='}'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3());
+ }
+ )
+;
+
+// Entry rule entryRuleXExpressionOrVarDeclaration
+entryRuleXExpressionOrVarDeclaration returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationRule()); }
+ iv_ruleXExpressionOrVarDeclaration=ruleXExpressionOrVarDeclaration
+ { $current=$iv_ruleXExpressionOrVarDeclaration.current; }
+ EOF;
+
+// Rule XExpressionOrVarDeclaration
+ruleXExpressionOrVarDeclaration returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0());
+ }
+ this_XVariableDeclaration_0=ruleXVariableDeclaration
+ {
+ $current = $this_XVariableDeclaration_0.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1());
+ }
+ this_XExpression_1=ruleXExpression
+ {
+ $current = $this_XExpression_1.current;
+ afterParserOrEnumRuleCall();
+ }
+ )
+;
+
+// Entry rule entryRuleXVariableDeclaration
+entryRuleXVariableDeclaration returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXVariableDeclarationRule()); }
+ iv_ruleXVariableDeclaration=ruleXVariableDeclaration
+ { $current=$iv_ruleXVariableDeclaration.current; }
+ EOF;
+
+// Rule XVariableDeclaration
+ruleXVariableDeclaration returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0(),
+ $current);
+ }
+ )
+ (
+ (
+ (
+ lv_writeable_1_0='var'
+ {
+ newLeafNode(lv_writeable_1_0, grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXVariableDeclarationRule());
+ }
+ setWithLastConsumed($current, "writeable", true, "var");
+ }
+ )
+ )
+ |
+ otherlv_2='val'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1());
+ }
+ )
+ (
+ (
+ ((
+ (
+ (
+ ruleJvmTypeReference
+ )
+ )
+ (
+ (
+ ruleValidID
+ )
+ )
+ )
+ )=>
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0());
+ }
+ lv_type_3_0=ruleJvmTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+ }
+ set(
+ $current,
+ "type",
+ lv_type_3_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0());
+ }
+ lv_name_4_0=ruleValidID
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_4_0,
+ "org.eclipse.xtext.xbase.Xtype.ValidID");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ )
+ |
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0());
+ }
+ lv_name_5_0=ruleValidID
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_5_0,
+ "org.eclipse.xtext.xbase.Xtype.ValidID");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ (
+ otherlv_6='='
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0());
+ }
+ lv_right_7_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+ }
+ set(
+ $current,
+ "right",
+ lv_right_7_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )?
+ )
+;
+
+// Entry rule entryRuleJvmFormalParameter
+entryRuleJvmFormalParameter returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getJvmFormalParameterRule()); }
+ iv_ruleJvmFormalParameter=ruleJvmFormalParameter
+ { $current=$iv_ruleJvmFormalParameter.current; }
+ EOF;
+
+// Rule JvmFormalParameter
+ruleJvmFormalParameter returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0());
+ }
+ lv_parameterType_0_0=ruleJvmTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule());
+ }
+ set(
+ $current,
+ "parameterType",
+ lv_parameterType_0_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )?
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0());
+ }
+ lv_name_1_0=ruleValidID
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_1_0,
+ "org.eclipse.xtext.xbase.Xtype.ValidID");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleFullJvmFormalParameter
+entryRuleFullJvmFormalParameter returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getFullJvmFormalParameterRule()); }
+ iv_ruleFullJvmFormalParameter=ruleFullJvmFormalParameter
+ { $current=$iv_ruleFullJvmFormalParameter.current; }
+ EOF;
+
+// Rule FullJvmFormalParameter
+ruleFullJvmFormalParameter returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0());
+ }
+ lv_parameterType_0_0=ruleJvmTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule());
+ }
+ set(
+ $current,
+ "parameterType",
+ lv_parameterType_0_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0());
+ }
+ lv_name_1_0=ruleValidID
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_1_0,
+ "org.eclipse.xtext.xbase.Xtype.ValidID");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleXFeatureCall
+entryRuleXFeatureCall returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXFeatureCallRule()); }
+ iv_ruleXFeatureCall=ruleXFeatureCall
+ { $current=$iv_ruleXFeatureCall.current; }
+ EOF;
+
+// Rule XFeatureCall
+ruleXFeatureCall returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0(),
+ $current);
+ }
+ )
+ (
+ otherlv_1='<'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0());
+ }
+ lv_typeArguments_2_0=ruleJvmArgumentTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ $current,
+ "typeArguments",
+ lv_typeArguments_2_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_3=','
+ {
+ newLeafNode(otherlv_3, grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0());
+ }
+ lv_typeArguments_4_0=ruleJvmArgumentTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ $current,
+ "typeArguments",
+ lv_typeArguments_4_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ otherlv_5='>'
+ {
+ newLeafNode(otherlv_5, grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3());
+ }
+ )?
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXFeatureCallRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0());
+ }
+ ruleIdOrSuper
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ (
+ ((
+ '('
+ )
+ )=>
+ (
+ lv_explicitOperationCall_7_0='('
+ {
+ newLeafNode(lv_explicitOperationCall_7_0, grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXFeatureCallRule());
+ }
+ setWithLastConsumed($current, "explicitOperationCall", true, "(");
+ }
+ )
+ )
+ (
+ (
+ ((
+ (
+ )
+ (
+ (
+ (
+ ruleJvmFormalParameter
+ )
+ )
+ (
+ ','
+ (
+ (
+ ruleJvmFormalParameter
+ )
+ )
+ )*
+ )?
+ (
+ (
+ '|'
+ )
+ )
+ )
+ )=>
+ (
+ {
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0());
+ }
+ lv_featureCallArguments_8_0=ruleXShortClosure
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ $current,
+ "featureCallArguments",
+ lv_featureCallArguments_8_0,
+ "org.eclipse.xtext.xbase.Xbase.XShortClosure");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ |
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0());
+ }
+ lv_featureCallArguments_9_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ $current,
+ "featureCallArguments",
+ lv_featureCallArguments_9_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_10=','
+ {
+ newLeafNode(otherlv_10, grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0());
+ }
+ lv_featureCallArguments_11_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ $current,
+ "featureCallArguments",
+ lv_featureCallArguments_11_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )
+ )?
+ otherlv_12=')'
+ {
+ newLeafNode(otherlv_12, grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2());
+ }
+ )?
+ (
+ ((
+ (
+ )
+ '['
+ )
+ )=>
+ (
+ {
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0());
+ }
+ lv_featureCallArguments_13_0=ruleXClosure
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ $current,
+ "featureCallArguments",
+ lv_featureCallArguments_13_0,
+ "org.eclipse.xtext.xbase.Xbase.XClosure");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )?
+ )
+;
+
+// Entry rule entryRuleFeatureCallID
+entryRuleFeatureCallID returns [String current=null]:
+ { newCompositeNode(grammarAccess.getFeatureCallIDRule()); }
+ iv_ruleFeatureCallID=ruleFeatureCallID
+ { $current=$iv_ruleFeatureCallID.current.getText(); }
+ EOF;
+
+// Rule FeatureCallID
+ruleFeatureCallID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0());
+ }
+ this_ValidID_0=ruleValidID
+ {
+ $current.merge(this_ValidID_0);
+ }
+ {
+ afterParserOrEnumRuleCall();
+ }
+ |
+ kw='extends'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1());
+ }
+ |
+ kw='static'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2());
+ }
+ |
+ kw='import'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getImportKeyword_3());
+ }
+ |
+ kw='extension'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4());
+ }
+ )
+;
+
+// Entry rule entryRuleIdOrSuper
+entryRuleIdOrSuper returns [String current=null]:
+ { newCompositeNode(grammarAccess.getIdOrSuperRule()); }
+ iv_ruleIdOrSuper=ruleIdOrSuper
+ { $current=$iv_ruleIdOrSuper.current.getText(); }
+ EOF;
+
+// Rule IdOrSuper
+ruleIdOrSuper returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0());
+ }
+ this_FeatureCallID_0=ruleFeatureCallID
+ {
+ $current.merge(this_FeatureCallID_0);
+ }
+ {
+ afterParserOrEnumRuleCall();
+ }
+ |
+ kw='super'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getIdOrSuperAccess().getSuperKeyword_1());
+ }
+ )
+;
+
+// Entry rule entryRuleXConstructorCall
+entryRuleXConstructorCall returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXConstructorCallRule()); }
+ iv_ruleXConstructorCall=ruleXConstructorCall
+ { $current=$iv_ruleXConstructorCall.current; }
+ EOF;
+
+// Rule XConstructorCall
+ruleXConstructorCall returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0(),
+ $current);
+ }
+ )
+ otherlv_1='new'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXConstructorCallAccess().getNewKeyword_1());
+ }
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXConstructorCallRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0());
+ }
+ ruleQualifiedName
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ (
+ ('<')=>
+ otherlv_3='<'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0());
+ }
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0());
+ }
+ lv_typeArguments_4_0=ruleJvmArgumentTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ $current,
+ "typeArguments",
+ lv_typeArguments_4_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_5=','
+ {
+ newLeafNode(otherlv_5, grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0());
+ }
+ lv_typeArguments_6_0=ruleJvmArgumentTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ $current,
+ "typeArguments",
+ lv_typeArguments_6_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ otherlv_7='>'
+ {
+ newLeafNode(otherlv_7, grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3());
+ }
+ )?
+ (
+ (
+ ((
+ '('
+ )
+ )=>
+ (
+ lv_explicitConstructorCall_8_0='('
+ {
+ newLeafNode(lv_explicitConstructorCall_8_0, grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXConstructorCallRule());
+ }
+ setWithLastConsumed($current, "explicitConstructorCall", true, "(");
+ }
+ )
+ )
+ (
+ (
+ ((
+ (
+ )
+ (
+ (
+ (
+ ruleJvmFormalParameter
+ )
+ )
+ (
+ ','
+ (
+ (
+ ruleJvmFormalParameter
+ )
+ )
+ )*
+ )?
+ (
+ (
+ '|'
+ )
+ )
+ )
+ )=>
+ (
+ {
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0());
+ }
+ lv_arguments_9_0=ruleXShortClosure
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ $current,
+ "arguments",
+ lv_arguments_9_0,
+ "org.eclipse.xtext.xbase.Xbase.XShortClosure");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ |
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0());
+ }
+ lv_arguments_10_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ $current,
+ "arguments",
+ lv_arguments_10_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_11=','
+ {
+ newLeafNode(otherlv_11, grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0());
+ }
+ lv_arguments_12_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ $current,
+ "arguments",
+ lv_arguments_12_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )
+ )?
+ otherlv_13=')'
+ {
+ newLeafNode(otherlv_13, grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2());
+ }
+ )?
+ (
+ ((
+ (
+ )
+ '['
+ )
+ )=>
+ (
+ {
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0());
+ }
+ lv_arguments_14_0=ruleXClosure
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ $current,
+ "arguments",
+ lv_arguments_14_0,
+ "org.eclipse.xtext.xbase.Xbase.XClosure");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )?
+ )
+;
+
+// Entry rule entryRuleXBooleanLiteral
+entryRuleXBooleanLiteral returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXBooleanLiteralRule()); }
+ iv_ruleXBooleanLiteral=ruleXBooleanLiteral
+ { $current=$iv_ruleXBooleanLiteral.current; }
+ EOF;
+
+// Rule XBooleanLiteral
+ruleXBooleanLiteral returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0(),
+ $current);
+ }
+ )
+ (
+ otherlv_1='false'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0());
+ }
+ |
+ (
+ (
+ lv_isTrue_2_0='true'
+ {
+ newLeafNode(lv_isTrue_2_0, grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXBooleanLiteralRule());
+ }
+ setWithLastConsumed($current, "isTrue", true, "true");
+ }
+ )
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleXNullLiteral
+entryRuleXNullLiteral returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXNullLiteralRule()); }
+ iv_ruleXNullLiteral=ruleXNullLiteral
+ { $current=$iv_ruleXNullLiteral.current; }
+ EOF;
+
+// Rule XNullLiteral
+ruleXNullLiteral returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0(),
+ $current);
+ }
+ )
+ otherlv_1='null'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXNullLiteralAccess().getNullKeyword_1());
+ }
+ )
+;
+
+// Entry rule entryRuleXNumberLiteral
+entryRuleXNumberLiteral returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXNumberLiteralRule()); }
+ iv_ruleXNumberLiteral=ruleXNumberLiteral
+ { $current=$iv_ruleXNumberLiteral.current; }
+ EOF;
+
+// Rule XNumberLiteral
+ruleXNumberLiteral returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0(),
+ $current);
+ }
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0());
+ }
+ lv_value_1_0=ruleNumber
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXNumberLiteralRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_1_0,
+ "org.eclipse.xtext.xbase.Xbase.Number");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleXStringLiteral
+entryRuleXStringLiteral returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXStringLiteralRule()); }
+ iv_ruleXStringLiteral=ruleXStringLiteral
+ { $current=$iv_ruleXStringLiteral.current; }
+ EOF;
+
+// Rule XStringLiteral
+ruleXStringLiteral returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0(),
+ $current);
+ }
+ )
+ (
+ (
+ lv_value_1_0=RULE_STRING
+ {
+ newLeafNode(lv_value_1_0, grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXStringLiteralRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "value",
+ lv_value_1_0,
+ "org.eclipse.xtext.xbase.Xtype.STRING");
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleXTypeLiteral
+entryRuleXTypeLiteral returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXTypeLiteralRule()); }
+ iv_ruleXTypeLiteral=ruleXTypeLiteral
+ { $current=$iv_ruleXTypeLiteral.current; }
+ EOF;
+
+// Rule XTypeLiteral
+ruleXTypeLiteral returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0(),
+ $current);
+ }
+ )
+ otherlv_1='typeof'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1());
+ }
+ otherlv_2='('
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2());
+ }
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXTypeLiteralRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0());
+ }
+ ruleQualifiedName
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0());
+ }
+ lv_arrayDimensions_4_0=ruleArrayBrackets
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXTypeLiteralRule());
+ }
+ add(
+ $current,
+ "arrayDimensions",
+ lv_arrayDimensions_4_0,
+ "org.eclipse.xtext.xbase.Xtype.ArrayBrackets");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )*
+ otherlv_5=')'
+ {
+ newLeafNode(otherlv_5, grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5());
+ }
+ )
+;
+
+// Entry rule entryRuleXThrowExpression
+entryRuleXThrowExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXThrowExpressionRule()); }
+ iv_ruleXThrowExpression=ruleXThrowExpression
+ { $current=$iv_ruleXThrowExpression.current; }
+ EOF;
+
+// Rule XThrowExpression
+ruleXThrowExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0(),
+ $current);
+ }
+ )
+ otherlv_1='throw'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+ }
+ lv_expression_2_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXThrowExpressionRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_2_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleXReturnExpression
+entryRuleXReturnExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXReturnExpressionRule()); }
+ iv_ruleXReturnExpression=ruleXReturnExpression
+ { $current=$iv_ruleXReturnExpression.current; }
+ EOF;
+
+// Rule XReturnExpression
+ruleXReturnExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0(),
+ $current);
+ }
+ )
+ otherlv_1='return'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1());
+ }
+ (
+ ('extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING)=>
+ (
+ {
+ newCompositeNode(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+ }
+ lv_expression_2_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXReturnExpressionRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_2_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )?
+ )
+;
+
+// Entry rule entryRuleXTryCatchFinallyExpression
+entryRuleXTryCatchFinallyExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionRule()); }
+ iv_ruleXTryCatchFinallyExpression=ruleXTryCatchFinallyExpression
+ { $current=$iv_ruleXTryCatchFinallyExpression.current; }
+ EOF;
+
+// Rule XTryCatchFinallyExpression
+ruleXTryCatchFinallyExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0(),
+ $current);
+ }
+ )
+ otherlv_1='try'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+ }
+ lv_expression_2_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_2_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ (
+ (
+ ('catch')=>
+ (
+ {
+ newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0());
+ }
+ lv_catchClauses_3_0=ruleXCatchClause
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule());
+ }
+ add(
+ $current,
+ "catchClauses",
+ lv_catchClauses_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XCatchClause");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )+
+ (
+ (
+ ('finally')=>
+ otherlv_4='finally'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0());
+ }
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0());
+ }
+ lv_finallyExpression_5_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule());
+ }
+ set(
+ $current,
+ "finallyExpression",
+ lv_finallyExpression_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )?
+ )
+ |
+ (
+ otherlv_6='finally'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0());
+ }
+ lv_finallyExpression_7_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule());
+ }
+ set(
+ $current,
+ "finallyExpression",
+ lv_finallyExpression_7_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleXSynchronizedExpression
+entryRuleXSynchronizedExpression returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXSynchronizedExpressionRule()); }
+ iv_ruleXSynchronizedExpression=ruleXSynchronizedExpression
+ { $current=$iv_ruleXSynchronizedExpression.current; }
+ EOF;
+
+// Rule XSynchronizedExpression
+ruleXSynchronizedExpression returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ ((
+ (
+ )
+ 'synchronized'
+ '('
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0(),
+ $current);
+ }
+ )
+ otherlv_1='synchronized'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1());
+ }
+ otherlv_2='('
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2());
+ }
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0());
+ }
+ lv_param_3_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule());
+ }
+ set(
+ $current,
+ "param",
+ lv_param_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ otherlv_4=')'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0());
+ }
+ lv_expression_5_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleXCatchClause
+entryRuleXCatchClause returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXCatchClauseRule()); }
+ iv_ruleXCatchClause=ruleXCatchClause
+ { $current=$iv_ruleXCatchClause.current; }
+ EOF;
+
+// Rule XCatchClause
+ruleXCatchClause returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ ('catch')=>
+ otherlv_0='catch'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getXCatchClauseAccess().getCatchKeyword_0());
+ }
+ )
+ otherlv_1='('
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0());
+ }
+ lv_declaredParam_2_0=ruleFullJvmFormalParameter
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXCatchClauseRule());
+ }
+ set(
+ $current,
+ "declaredParam",
+ lv_declaredParam_2_0,
+ "org.eclipse.xtext.xbase.Xbase.FullJvmFormalParameter");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ otherlv_3=')'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0());
+ }
+ lv_expression_4_0=ruleXExpression
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXCatchClauseRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_4_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleQualifiedName
+entryRuleQualifiedName returns [String current=null]:
+ { newCompositeNode(grammarAccess.getQualifiedNameRule()); }
+ iv_ruleQualifiedName=ruleQualifiedName
+ { $current=$iv_ruleQualifiedName.current.getText(); }
+ EOF;
+
+// Rule QualifiedName
+ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0());
+ }
+ this_ValidID_0=ruleValidID
+ {
+ $current.merge(this_ValidID_0);
+ }
+ {
+ afterParserOrEnumRuleCall();
+ }
+ (
+ (
+ ('.')=>
+ kw='.'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0());
+ }
+ )
+ {
+ newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1());
+ }
+ this_ValidID_2=ruleValidID
+ {
+ $current.merge(this_ValidID_2);
+ }
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )*
+ )
+;
+
+// Entry rule entryRuleNumber
+entryRuleNumber returns [String current=null]@init {
+ HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+}:
+ { newCompositeNode(grammarAccess.getNumberRule()); }
+ iv_ruleNumber=ruleNumber
+ { $current=$iv_ruleNumber.current.getText(); }
+ EOF;
+finally {
+ myHiddenTokenState.restore();
+}
+
+// Rule Number
+ruleNumber returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+ HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+}
+@after {
+ leaveRule();
+}:
+ (
+ this_HEX_0=RULE_HEX
+ {
+ $current.merge(this_HEX_0);
+ }
+ {
+ newLeafNode(this_HEX_0, grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0());
+ }
+ |
+ (
+ (
+ this_INT_1=RULE_INT
+ {
+ $current.merge(this_INT_1);
+ }
+ {
+ newLeafNode(this_INT_1, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0());
+ }
+ |
+ this_DECIMAL_2=RULE_DECIMAL
+ {
+ $current.merge(this_DECIMAL_2);
+ }
+ {
+ newLeafNode(this_DECIMAL_2, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1());
+ }
+ )
+ (
+ kw='.'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0());
+ }
+ (
+ this_INT_4=RULE_INT
+ {
+ $current.merge(this_INT_4);
+ }
+ {
+ newLeafNode(this_INT_4, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0());
+ }
+ |
+ this_DECIMAL_5=RULE_DECIMAL
+ {
+ $current.merge(this_DECIMAL_5);
+ }
+ {
+ newLeafNode(this_DECIMAL_5, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1());
+ }
+ )
+ )?
+ )
+ )
+;
+finally {
+ myHiddenTokenState.restore();
+}
+
+// Entry rule entryRuleJvmTypeReference
+entryRuleJvmTypeReference returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getJvmTypeReferenceRule()); }
+ iv_ruleJvmTypeReference=ruleJvmTypeReference
+ { $current=$iv_ruleJvmTypeReference.current; }
+ EOF;
+
+// Rule JvmTypeReference
+ruleJvmTypeReference returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0());
+ }
+ this_JvmParameterizedTypeReference_0=ruleJvmParameterizedTypeReference
+ {
+ $current = $this_JvmParameterizedTypeReference_0.current;
+ afterParserOrEnumRuleCall();
+ }
+ (
+ ((
+ (
+ )
+ ruleArrayBrackets
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0(),
+ $current);
+ }
+ )
+ {
+ newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1());
+ }
+ ruleArrayBrackets
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )*
+ )
+ |
+ {
+ newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1());
+ }
+ this_XFunctionTypeRef_3=ruleXFunctionTypeRef
+ {
+ $current = $this_XFunctionTypeRef_3.current;
+ afterParserOrEnumRuleCall();
+ }
+ )
+;
+
+// Entry rule entryRuleArrayBrackets
+entryRuleArrayBrackets returns [String current=null]:
+ { newCompositeNode(grammarAccess.getArrayBracketsRule()); }
+ iv_ruleArrayBrackets=ruleArrayBrackets
+ { $current=$iv_ruleArrayBrackets.current.getText(); }
+ EOF;
+
+// Rule ArrayBrackets
+ruleArrayBrackets returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ kw='['
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0());
+ }
+ kw=']'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1());
+ }
+ )
+;
+
+// Entry rule entryRuleXFunctionTypeRef
+entryRuleXFunctionTypeRef returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXFunctionTypeRefRule()); }
+ iv_ruleXFunctionTypeRef=ruleXFunctionTypeRef
+ { $current=$iv_ruleXFunctionTypeRef.current; }
+ EOF;
+
+// Rule XFunctionTypeRef
+ruleXFunctionTypeRef returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ otherlv_0='('
+ {
+ newLeafNode(otherlv_0, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0());
+ }
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0());
+ }
+ lv_paramTypes_1_0=ruleJvmTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule());
+ }
+ add(
+ $current,
+ "paramTypes",
+ lv_paramTypes_1_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_2=','
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0());
+ }
+ lv_paramTypes_3_0=ruleJvmTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule());
+ }
+ add(
+ $current,
+ "paramTypes",
+ lv_paramTypes_3_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ )?
+ otherlv_4=')'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2());
+ }
+ )?
+ otherlv_5='=>'
+ {
+ newLeafNode(otherlv_5, grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0());
+ }
+ lv_returnType_6_0=ruleJvmTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule());
+ }
+ set(
+ $current,
+ "returnType",
+ lv_returnType_6_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleJvmParameterizedTypeReference
+entryRuleJvmParameterizedTypeReference returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceRule()); }
+ iv_ruleJvmParameterizedTypeReference=ruleJvmParameterizedTypeReference
+ { $current=$iv_ruleJvmParameterizedTypeReference.current; }
+ EOF;
+
+// Rule JvmParameterizedTypeReference
+ruleJvmParameterizedTypeReference returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0());
+ }
+ ruleQualifiedName
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ (
+ ('<')=>
+ otherlv_1='<'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0());
+ }
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0());
+ }
+ lv_arguments_2_0=ruleJvmArgumentTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule());
+ }
+ add(
+ $current,
+ "arguments",
+ lv_arguments_2_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_3=','
+ {
+ newLeafNode(otherlv_3, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0());
+ }
+ lv_arguments_4_0=ruleJvmArgumentTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule());
+ }
+ add(
+ $current,
+ "arguments",
+ lv_arguments_4_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ otherlv_5='>'
+ {
+ newLeafNode(otherlv_5, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3());
+ }
+ (
+ (
+ ((
+ (
+ )
+ '.'
+ )
+ )=>
+ (
+ (
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0(),
+ $current);
+ }
+ )
+ otherlv_7='.'
+ {
+ newLeafNode(otherlv_7, grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1());
+ }
+ )
+ )
+ (
+ (
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0());
+ }
+ ruleValidID
+ {
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ (
+ ('<')=>
+ otherlv_9='<'
+ {
+ newLeafNode(otherlv_9, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0());
+ }
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0());
+ }
+ lv_arguments_10_0=ruleJvmArgumentTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule());
+ }
+ add(
+ $current,
+ "arguments",
+ lv_arguments_10_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ otherlv_11=','
+ {
+ newLeafNode(otherlv_11, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0());
+ }
+ lv_arguments_12_0=ruleJvmArgumentTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule());
+ }
+ add(
+ $current,
+ "arguments",
+ lv_arguments_12_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )*
+ otherlv_13='>'
+ {
+ newLeafNode(otherlv_13, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3());
+ }
+ )?
+ )*
+ )?
+ )
+;
+
+// Entry rule entryRuleJvmArgumentTypeReference
+entryRuleJvmArgumentTypeReference returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceRule()); }
+ iv_ruleJvmArgumentTypeReference=ruleJvmArgumentTypeReference
+ { $current=$iv_ruleJvmArgumentTypeReference.current; }
+ EOF;
+
+// Rule JvmArgumentTypeReference
+ruleJvmArgumentTypeReference returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0());
+ }
+ this_JvmTypeReference_0=ruleJvmTypeReference
+ {
+ $current = $this_JvmTypeReference_0.current;
+ afterParserOrEnumRuleCall();
+ }
+ |
+ {
+ newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1());
+ }
+ this_JvmWildcardTypeReference_1=ruleJvmWildcardTypeReference
+ {
+ $current = $this_JvmWildcardTypeReference_1.current;
+ afterParserOrEnumRuleCall();
+ }
+ )
+;
+
+// Entry rule entryRuleJvmWildcardTypeReference
+entryRuleJvmWildcardTypeReference returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceRule()); }
+ iv_ruleJvmWildcardTypeReference=ruleJvmWildcardTypeReference
+ { $current=$iv_ruleJvmWildcardTypeReference.current; }
+ EOF;
+
+// Rule JvmWildcardTypeReference
+ruleJvmWildcardTypeReference returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0(),
+ $current);
+ }
+ )
+ otherlv_1='?'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1());
+ }
+ (
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0());
+ }
+ lv_constraints_2_0=ruleJvmUpperBound
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule());
+ }
+ add(
+ $current,
+ "constraints",
+ lv_constraints_2_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmUpperBound");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0());
+ }
+ lv_constraints_3_0=ruleJvmUpperBoundAnded
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule());
+ }
+ add(
+ $current,
+ "constraints",
+ lv_constraints_3_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmUpperBoundAnded");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )*
+ )
+ |
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0());
+ }
+ lv_constraints_4_0=ruleJvmLowerBound
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule());
+ }
+ add(
+ $current,
+ "constraints",
+ lv_constraints_4_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmLowerBound");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0());
+ }
+ lv_constraints_5_0=ruleJvmLowerBoundAnded
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule());
+ }
+ add(
+ $current,
+ "constraints",
+ lv_constraints_5_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmLowerBoundAnded");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )*
+ )
+ )?
+ )
+;
+
+// Entry rule entryRuleJvmUpperBound
+entryRuleJvmUpperBound returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getJvmUpperBoundRule()); }
+ iv_ruleJvmUpperBound=ruleJvmUpperBound
+ { $current=$iv_ruleJvmUpperBound.current; }
+ EOF;
+
+// Rule JvmUpperBound
+ruleJvmUpperBound returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ otherlv_0='extends'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+ }
+ lv_typeReference_1_0=ruleJvmTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getJvmUpperBoundRule());
+ }
+ set(
+ $current,
+ "typeReference",
+ lv_typeReference_1_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleJvmUpperBoundAnded
+entryRuleJvmUpperBoundAnded returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getJvmUpperBoundAndedRule()); }
+ iv_ruleJvmUpperBoundAnded=ruleJvmUpperBoundAnded
+ { $current=$iv_ruleJvmUpperBoundAnded.current; }
+ EOF;
+
+// Rule JvmUpperBoundAnded
+ruleJvmUpperBoundAnded returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ otherlv_0='&'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+ }
+ lv_typeReference_1_0=ruleJvmTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getJvmUpperBoundAndedRule());
+ }
+ set(
+ $current,
+ "typeReference",
+ lv_typeReference_1_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleJvmLowerBound
+entryRuleJvmLowerBound returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getJvmLowerBoundRule()); }
+ iv_ruleJvmLowerBound=ruleJvmLowerBound
+ { $current=$iv_ruleJvmLowerBound.current; }
+ EOF;
+
+// Rule JvmLowerBound
+ruleJvmLowerBound returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ otherlv_0='super'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+ }
+ lv_typeReference_1_0=ruleJvmTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getJvmLowerBoundRule());
+ }
+ set(
+ $current,
+ "typeReference",
+ lv_typeReference_1_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleJvmLowerBoundAnded
+entryRuleJvmLowerBoundAnded returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getJvmLowerBoundAndedRule()); }
+ iv_ruleJvmLowerBoundAnded=ruleJvmLowerBoundAnded
+ { $current=$iv_ruleJvmLowerBoundAnded.current; }
+ EOF;
+
+// Rule JvmLowerBoundAnded
+ruleJvmLowerBoundAnded returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ otherlv_0='&'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+ }
+ lv_typeReference_1_0=ruleJvmTypeReference
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getJvmLowerBoundAndedRule());
+ }
+ set(
+ $current,
+ "typeReference",
+ lv_typeReference_1_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleQualifiedNameWithWildcard
+entryRuleQualifiedNameWithWildcard returns [String current=null]:
+ { newCompositeNode(grammarAccess.getQualifiedNameWithWildcardRule()); }
+ iv_ruleQualifiedNameWithWildcard=ruleQualifiedNameWithWildcard
+ { $current=$iv_ruleQualifiedNameWithWildcard.current.getText(); }
+ EOF;
+
+// Rule QualifiedNameWithWildcard
+ruleQualifiedNameWithWildcard returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0());
+ }
+ this_QualifiedName_0=ruleQualifiedName
+ {
+ $current.merge(this_QualifiedName_0);
+ }
+ {
+ afterParserOrEnumRuleCall();
+ }
+ kw='.'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1());
+ }
+ kw='*'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2());
+ }
+ )
+;
+
+// Entry rule entryRuleValidID
+entryRuleValidID returns [String current=null]:
+ { newCompositeNode(grammarAccess.getValidIDRule()); }
+ iv_ruleValidID=ruleValidID
+ { $current=$iv_ruleValidID.current.getText(); }
+ EOF;
+
+// Rule ValidID
+ruleValidID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ this_ID_0=RULE_ID
+ {
+ $current.merge(this_ID_0);
+ }
+ {
+ newLeafNode(this_ID_0, grammarAccess.getValidIDAccess().getIDTerminalRuleCall());
+ }
+;
+
+// Entry rule entryRuleQualifiedNameInStaticImport
+entryRuleQualifiedNameInStaticImport returns [String current=null]:
+ { newCompositeNode(grammarAccess.getQualifiedNameInStaticImportRule()); }
+ iv_ruleQualifiedNameInStaticImport=ruleQualifiedNameInStaticImport
+ { $current=$iv_ruleQualifiedNameInStaticImport.current.getText(); }
+ EOF;
+
+// Rule QualifiedNameInStaticImport
+ruleQualifiedNameInStaticImport returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ {
+ newCompositeNode(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0());
+ }
+ this_ValidID_0=ruleValidID
+ {
+ $current.merge(this_ValidID_0);
+ }
+ {
+ afterParserOrEnumRuleCall();
+ }
+ kw='.'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1());
+ }
+ )+
+;
+
+RULE_HEX : ('0x'|'0X') ('0'..'9'|'a'..'f'|'A'..'F'|'_')+ ('#' (('b'|'B') ('i'|'I')|('l'|'L')))?;
+
+RULE_INT : '0'..'9' ('0'..'9'|'_')*;
+
+RULE_DECIMAL : RULE_INT (('e'|'E') ('+'|'-')? RULE_INT)? (('b'|'B') ('i'|'I'|'d'|'D')|('l'|'L'|'d'|'D'|'f'|'F'))?;
+
+RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'$'|'_') ('a'..'z'|'A'..'Z'|'$'|'_'|'0'..'9')*;
+
+RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'?|'\'' ('\\' .|~(('\\'|'\'')))* '\''?);
+
+RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/';
+
+RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?;
+
+RULE_WS : (' '|'\t'|'\r'|'\n')+;
+
+RULE_ANY_OTHER : .;
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtype.tokens b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtype.tokens
new file mode 100644
index 0000000..483763b
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtype.tokens
@@ -0,0 +1,161 @@
+'!'=53
+'!='=38
+'!=='=40
+'#'=24
+'%'=52
+'%='=31
+'&&'=36
+'&'=88
+'('=20
+')'=22
+'*'=16
+'**'=50
+'*='=29
+'+'=48
+'++'=55
+'+='=27
+','=21
+'-'=49
+'--'=56
+'-='=28
+'->'=42
+'.'=57
+'..'=44
+'..<'=43
+'/'=51
+'/='=30
+':'=66
+'::'=58
+';'=18
+'<'=32
+'<>'=46
+'='=23
+'=='=37
+'==='=39
+'=>'=45
+'>'=33
+'>='=34
+'?'=87
+'?.'=59
+'?:'=47
+'@'=19
+'['=25
+']'=26
+'as'=54
+'case'=68
+'catch'=86
+'default'=67
+'do'=71
+'else'=64
+'extends'=74
+'extension'=15
+'false'=77
+'finally'=84
+'for'=69
+'if'=63
+'import'=13
+'instanceof'=41
+'new'=76
+'ns'=17
+'null'=79
+'return'=82
+'static'=14
+'super'=75
+'switch'=65
+'synchronized'=85
+'throw'=81
+'true'=78
+'try'=83
+'typeof'=80
+'val'=73
+'var'=72
+'while'=70
+'{'=60
+'|'=62
+'||'=35
+'}'=61
+RULE_ANY_OTHER=12
+RULE_DECIMAL=7
+RULE_HEX=5
+RULE_ID=8
+RULE_INT=6
+RULE_ML_COMMENT=9
+RULE_SL_COMMENT=10
+RULE_STRING=4
+RULE_WS=11
+T__13=13
+T__14=14
+T__15=15
+T__16=16
+T__17=17
+T__18=18
+T__19=19
+T__20=20
+T__21=21
+T__22=22
+T__23=23
+T__24=24
+T__25=25
+T__26=26
+T__27=27
+T__28=28
+T__29=29
+T__30=30
+T__31=31
+T__32=32
+T__33=33
+T__34=34
+T__35=35
+T__36=36
+T__37=37
+T__38=38
+T__39=39
+T__40=40
+T__41=41
+T__42=42
+T__43=43
+T__44=44
+T__45=45
+T__46=46
+T__47=47
+T__48=48
+T__49=49
+T__50=50
+T__51=51
+T__52=52
+T__53=53
+T__54=54
+T__55=55
+T__56=56
+T__57=57
+T__58=58
+T__59=59
+T__60=60
+T__61=61
+T__62=62
+T__63=63
+T__64=64
+T__65=65
+T__66=66
+T__67=67
+T__68=68
+T__69=69
+T__70=70
+T__71=71
+T__72=72
+T__73=73
+T__74=74
+T__75=75
+T__76=76
+T__77=77
+T__78=78
+T__79=79
+T__80=80
+T__81=81
+T__82=82
+T__83=83
+T__84=84
+T__85=85
+T__86=86
+T__87=87
+T__88=88
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtypeLexer.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtypeLexer.java
new file mode 100644
index 0000000..aed79c6
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtypeLexer.java
@@ -0,0 +1,3533 @@
+package org.eclipse.osbp.xtext.oxtype.parser.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.parser.antlr.Lexer;
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+
+@SuppressWarnings("all")
+public class InternalOXtypeLexer extends Lexer {
+ public static final int RULE_HEX=5;
+ public static final int T__50=50;
+ public static final int T__19=19;
+ public static final int T__15=15;
+ public static final int T__59=59;
+ public static final int T__16=16;
+ public static final int T__17=17;
+ public static final int T__18=18;
+ public static final int T__55=55;
+ public static final int T__56=56;
+ public static final int T__13=13;
+ public static final int T__57=57;
+ public static final int T__14=14;
+ public static final int T__58=58;
+ public static final int T__51=51;
+ public static final int T__52=52;
+ public static final int T__53=53;
+ public static final int T__54=54;
+ public static final int T__60=60;
+ public static final int T__61=61;
+ public static final int RULE_ID=8;
+ public static final int RULE_DECIMAL=7;
+ public static final int T__26=26;
+ public static final int T__27=27;
+ public static final int T__28=28;
+ public static final int RULE_INT=6;
+ public static final int T__29=29;
+ public static final int T__22=22;
+ public static final int T__66=66;
+ public static final int RULE_ML_COMMENT=9;
+ public static final int T__23=23;
+ public static final int T__67=67;
+ public static final int T__24=24;
+ public static final int T__68=68;
+ public static final int T__25=25;
+ public static final int T__69=69;
+ public static final int T__62=62;
+ public static final int T__63=63;
+ public static final int T__20=20;
+ public static final int T__64=64;
+ public static final int T__21=21;
+ public static final int T__65=65;
+ public static final int T__70=70;
+ public static final int T__71=71;
+ public static final int T__72=72;
+ public static final int RULE_STRING=4;
+ public static final int RULE_SL_COMMENT=10;
+ public static final int T__37=37;
+ public static final int T__38=38;
+ public static final int T__39=39;
+ public static final int T__33=33;
+ public static final int T__77=77;
+ public static final int T__34=34;
+ public static final int T__78=78;
+ public static final int T__35=35;
+ public static final int T__79=79;
+ public static final int T__36=36;
+ public static final int T__73=73;
+ public static final int EOF=-1;
+ public static final int T__30=30;
+ public static final int T__74=74;
+ public static final int T__31=31;
+ public static final int T__75=75;
+ public static final int T__32=32;
+ public static final int T__76=76;
+ public static final int T__80=80;
+ public static final int T__81=81;
+ public static final int T__82=82;
+ public static final int T__83=83;
+ public static final int RULE_WS=11;
+ public static final int RULE_ANY_OTHER=12;
+ public static final int T__48=48;
+ public static final int T__49=49;
+ public static final int T__44=44;
+ public static final int T__88=88;
+ public static final int T__45=45;
+ public static final int T__46=46;
+ public static final int T__47=47;
+ public static final int T__40=40;
+ public static final int T__84=84;
+ public static final int T__41=41;
+ public static final int T__85=85;
+ public static final int T__42=42;
+ public static final int T__86=86;
+ public static final int T__43=43;
+ public static final int T__87=87;
+
+ // delegates
+ // delegators
+
+ public InternalOXtypeLexer() {;}
+ public InternalOXtypeLexer(CharStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public InternalOXtypeLexer(CharStream input, RecognizerSharedState state) {
+ super(input,state);
+
+ }
+ public String getGrammarFileName() { return "InternalOXtype.g"; }
+
+ // $ANTLR start "T__13"
+ public final void mT__13() throws RecognitionException {
+ try {
+ int _type = T__13;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:11:7: ( 'import' )
+ // InternalOXtype.g:11:9: 'import'
+ {
+ match("import");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__13"
+
+ // $ANTLR start "T__14"
+ public final void mT__14() throws RecognitionException {
+ try {
+ int _type = T__14;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:12:7: ( 'static' )
+ // InternalOXtype.g:12:9: 'static'
+ {
+ match("static");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__14"
+
+ // $ANTLR start "T__15"
+ public final void mT__15() throws RecognitionException {
+ try {
+ int _type = T__15;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:13:7: ( 'extension' )
+ // InternalOXtype.g:13:9: 'extension'
+ {
+ match("extension");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__15"
+
+ // $ANTLR start "T__16"
+ public final void mT__16() throws RecognitionException {
+ try {
+ int _type = T__16;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:14:7: ( '*' )
+ // InternalOXtype.g:14:9: '*'
+ {
+ match('*');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__16"
+
+ // $ANTLR start "T__17"
+ public final void mT__17() throws RecognitionException {
+ try {
+ int _type = T__17;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:15:7: ( 'ns' )
+ // InternalOXtype.g:15:9: 'ns'
+ {
+ match("ns");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__17"
+
+ // $ANTLR start "T__18"
+ public final void mT__18() throws RecognitionException {
+ try {
+ int _type = T__18;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:16:7: ( ';' )
+ // InternalOXtype.g:16:9: ';'
+ {
+ match(';');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__18"
+
+ // $ANTLR start "T__19"
+ public final void mT__19() throws RecognitionException {
+ try {
+ int _type = T__19;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:17:7: ( '@' )
+ // InternalOXtype.g:17:9: '@'
+ {
+ match('@');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__19"
+
+ // $ANTLR start "T__20"
+ public final void mT__20() throws RecognitionException {
+ try {
+ int _type = T__20;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:18:7: ( '(' )
+ // InternalOXtype.g:18:9: '('
+ {
+ match('(');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__20"
+
+ // $ANTLR start "T__21"
+ public final void mT__21() throws RecognitionException {
+ try {
+ int _type = T__21;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:19:7: ( ',' )
+ // InternalOXtype.g:19:9: ','
+ {
+ match(',');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__21"
+
+ // $ANTLR start "T__22"
+ public final void mT__22() throws RecognitionException {
+ try {
+ int _type = T__22;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:20:7: ( ')' )
+ // InternalOXtype.g:20:9: ')'
+ {
+ match(')');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__22"
+
+ // $ANTLR start "T__23"
+ public final void mT__23() throws RecognitionException {
+ try {
+ int _type = T__23;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:21:7: ( '=' )
+ // InternalOXtype.g:21:9: '='
+ {
+ match('=');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__23"
+
+ // $ANTLR start "T__24"
+ public final void mT__24() throws RecognitionException {
+ try {
+ int _type = T__24;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:22:7: ( '#' )
+ // InternalOXtype.g:22:9: '#'
+ {
+ match('#');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__24"
+
+ // $ANTLR start "T__25"
+ public final void mT__25() throws RecognitionException {
+ try {
+ int _type = T__25;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:23:7: ( '[' )
+ // InternalOXtype.g:23:9: '['
+ {
+ match('[');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__25"
+
+ // $ANTLR start "T__26"
+ public final void mT__26() throws RecognitionException {
+ try {
+ int _type = T__26;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:24:7: ( ']' )
+ // InternalOXtype.g:24:9: ']'
+ {
+ match(']');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__26"
+
+ // $ANTLR start "T__27"
+ public final void mT__27() throws RecognitionException {
+ try {
+ int _type = T__27;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:25:7: ( '+=' )
+ // InternalOXtype.g:25:9: '+='
+ {
+ match("+=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__27"
+
+ // $ANTLR start "T__28"
+ public final void mT__28() throws RecognitionException {
+ try {
+ int _type = T__28;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:26:7: ( '-=' )
+ // InternalOXtype.g:26:9: '-='
+ {
+ match("-=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__28"
+
+ // $ANTLR start "T__29"
+ public final void mT__29() throws RecognitionException {
+ try {
+ int _type = T__29;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:27:7: ( '*=' )
+ // InternalOXtype.g:27:9: '*='
+ {
+ match("*=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__29"
+
+ // $ANTLR start "T__30"
+ public final void mT__30() throws RecognitionException {
+ try {
+ int _type = T__30;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:28:7: ( '/=' )
+ // InternalOXtype.g:28:9: '/='
+ {
+ match("/=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__30"
+
+ // $ANTLR start "T__31"
+ public final void mT__31() throws RecognitionException {
+ try {
+ int _type = T__31;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:29:7: ( '%=' )
+ // InternalOXtype.g:29:9: '%='
+ {
+ match("%=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__31"
+
+ // $ANTLR start "T__32"
+ public final void mT__32() throws RecognitionException {
+ try {
+ int _type = T__32;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:30:7: ( '<' )
+ // InternalOXtype.g:30:9: '<'
+ {
+ match('<');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__32"
+
+ // $ANTLR start "T__33"
+ public final void mT__33() throws RecognitionException {
+ try {
+ int _type = T__33;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:31:7: ( '>' )
+ // InternalOXtype.g:31:9: '>'
+ {
+ match('>');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__33"
+
+ // $ANTLR start "T__34"
+ public final void mT__34() throws RecognitionException {
+ try {
+ int _type = T__34;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:32:7: ( '>=' )
+ // InternalOXtype.g:32:9: '>='
+ {
+ match(">=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__34"
+
+ // $ANTLR start "T__35"
+ public final void mT__35() throws RecognitionException {
+ try {
+ int _type = T__35;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:33:7: ( '||' )
+ // InternalOXtype.g:33:9: '||'
+ {
+ match("||");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__35"
+
+ // $ANTLR start "T__36"
+ public final void mT__36() throws RecognitionException {
+ try {
+ int _type = T__36;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:34:7: ( '&&' )
+ // InternalOXtype.g:34:9: '&&'
+ {
+ match("&&");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__36"
+
+ // $ANTLR start "T__37"
+ public final void mT__37() throws RecognitionException {
+ try {
+ int _type = T__37;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:35:7: ( '==' )
+ // InternalOXtype.g:35:9: '=='
+ {
+ match("==");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__37"
+
+ // $ANTLR start "T__38"
+ public final void mT__38() throws RecognitionException {
+ try {
+ int _type = T__38;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:36:7: ( '!=' )
+ // InternalOXtype.g:36:9: '!='
+ {
+ match("!=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__38"
+
+ // $ANTLR start "T__39"
+ public final void mT__39() throws RecognitionException {
+ try {
+ int _type = T__39;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:37:7: ( '===' )
+ // InternalOXtype.g:37:9: '==='
+ {
+ match("===");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__39"
+
+ // $ANTLR start "T__40"
+ public final void mT__40() throws RecognitionException {
+ try {
+ int _type = T__40;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:38:7: ( '!==' )
+ // InternalOXtype.g:38:9: '!=='
+ {
+ match("!==");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__40"
+
+ // $ANTLR start "T__41"
+ public final void mT__41() throws RecognitionException {
+ try {
+ int _type = T__41;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:39:7: ( 'instanceof' )
+ // InternalOXtype.g:39:9: 'instanceof'
+ {
+ match("instanceof");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__41"
+
+ // $ANTLR start "T__42"
+ public final void mT__42() throws RecognitionException {
+ try {
+ int _type = T__42;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:40:7: ( '->' )
+ // InternalOXtype.g:40:9: '->'
+ {
+ match("->");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__42"
+
+ // $ANTLR start "T__43"
+ public final void mT__43() throws RecognitionException {
+ try {
+ int _type = T__43;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:41:7: ( '..<' )
+ // InternalOXtype.g:41:9: '..<'
+ {
+ match("..<");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__43"
+
+ // $ANTLR start "T__44"
+ public final void mT__44() throws RecognitionException {
+ try {
+ int _type = T__44;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:42:7: ( '..' )
+ // InternalOXtype.g:42:9: '..'
+ {
+ match("..");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__44"
+
+ // $ANTLR start "T__45"
+ public final void mT__45() throws RecognitionException {
+ try {
+ int _type = T__45;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:43:7: ( '=>' )
+ // InternalOXtype.g:43:9: '=>'
+ {
+ match("=>");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__45"
+
+ // $ANTLR start "T__46"
+ public final void mT__46() throws RecognitionException {
+ try {
+ int _type = T__46;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:44:7: ( '<>' )
+ // InternalOXtype.g:44:9: '<>'
+ {
+ match("<>");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__46"
+
+ // $ANTLR start "T__47"
+ public final void mT__47() throws RecognitionException {
+ try {
+ int _type = T__47;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:45:7: ( '?:' )
+ // InternalOXtype.g:45:9: '?:'
+ {
+ match("?:");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__47"
+
+ // $ANTLR start "T__48"
+ public final void mT__48() throws RecognitionException {
+ try {
+ int _type = T__48;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:46:7: ( '+' )
+ // InternalOXtype.g:46:9: '+'
+ {
+ match('+');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__48"
+
+ // $ANTLR start "T__49"
+ public final void mT__49() throws RecognitionException {
+ try {
+ int _type = T__49;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:47:7: ( '-' )
+ // InternalOXtype.g:47:9: '-'
+ {
+ match('-');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__49"
+
+ // $ANTLR start "T__50"
+ public final void mT__50() throws RecognitionException {
+ try {
+ int _type = T__50;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:48:7: ( '**' )
+ // InternalOXtype.g:48:9: '**'
+ {
+ match("**");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__50"
+
+ // $ANTLR start "T__51"
+ public final void mT__51() throws RecognitionException {
+ try {
+ int _type = T__51;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:49:7: ( '/' )
+ // InternalOXtype.g:49:9: '/'
+ {
+ match('/');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__51"
+
+ // $ANTLR start "T__52"
+ public final void mT__52() throws RecognitionException {
+ try {
+ int _type = T__52;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:50:7: ( '%' )
+ // InternalOXtype.g:50:9: '%'
+ {
+ match('%');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__52"
+
+ // $ANTLR start "T__53"
+ public final void mT__53() throws RecognitionException {
+ try {
+ int _type = T__53;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:51:7: ( '!' )
+ // InternalOXtype.g:51:9: '!'
+ {
+ match('!');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__53"
+
+ // $ANTLR start "T__54"
+ public final void mT__54() throws RecognitionException {
+ try {
+ int _type = T__54;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:52:7: ( 'as' )
+ // InternalOXtype.g:52:9: 'as'
+ {
+ match("as");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__54"
+
+ // $ANTLR start "T__55"
+ public final void mT__55() throws RecognitionException {
+ try {
+ int _type = T__55;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:53:7: ( '++' )
+ // InternalOXtype.g:53:9: '++'
+ {
+ match("++");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__55"
+
+ // $ANTLR start "T__56"
+ public final void mT__56() throws RecognitionException {
+ try {
+ int _type = T__56;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:54:7: ( '--' )
+ // InternalOXtype.g:54:9: '--'
+ {
+ match("--");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__56"
+
+ // $ANTLR start "T__57"
+ public final void mT__57() throws RecognitionException {
+ try {
+ int _type = T__57;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:55:7: ( '.' )
+ // InternalOXtype.g:55:9: '.'
+ {
+ match('.');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__57"
+
+ // $ANTLR start "T__58"
+ public final void mT__58() throws RecognitionException {
+ try {
+ int _type = T__58;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:56:7: ( '::' )
+ // InternalOXtype.g:56:9: '::'
+ {
+ match("::");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__58"
+
+ // $ANTLR start "T__59"
+ public final void mT__59() throws RecognitionException {
+ try {
+ int _type = T__59;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:57:7: ( '?.' )
+ // InternalOXtype.g:57:9: '?.'
+ {
+ match("?.");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__59"
+
+ // $ANTLR start "T__60"
+ public final void mT__60() throws RecognitionException {
+ try {
+ int _type = T__60;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:58:7: ( '{' )
+ // InternalOXtype.g:58:9: '{'
+ {
+ match('{');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__60"
+
+ // $ANTLR start "T__61"
+ public final void mT__61() throws RecognitionException {
+ try {
+ int _type = T__61;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:59:7: ( '}' )
+ // InternalOXtype.g:59:9: '}'
+ {
+ match('}');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__61"
+
+ // $ANTLR start "T__62"
+ public final void mT__62() throws RecognitionException {
+ try {
+ int _type = T__62;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:60:7: ( '|' )
+ // InternalOXtype.g:60:9: '|'
+ {
+ match('|');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__62"
+
+ // $ANTLR start "T__63"
+ public final void mT__63() throws RecognitionException {
+ try {
+ int _type = T__63;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:61:7: ( 'if' )
+ // InternalOXtype.g:61:9: 'if'
+ {
+ match("if");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__63"
+
+ // $ANTLR start "T__64"
+ public final void mT__64() throws RecognitionException {
+ try {
+ int _type = T__64;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:62:7: ( 'else' )
+ // InternalOXtype.g:62:9: 'else'
+ {
+ match("else");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__64"
+
+ // $ANTLR start "T__65"
+ public final void mT__65() throws RecognitionException {
+ try {
+ int _type = T__65;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:63:7: ( 'switch' )
+ // InternalOXtype.g:63:9: 'switch'
+ {
+ match("switch");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__65"
+
+ // $ANTLR start "T__66"
+ public final void mT__66() throws RecognitionException {
+ try {
+ int _type = T__66;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:64:7: ( ':' )
+ // InternalOXtype.g:64:9: ':'
+ {
+ match(':');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__66"
+
+ // $ANTLR start "T__67"
+ public final void mT__67() throws RecognitionException {
+ try {
+ int _type = T__67;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:65:7: ( 'default' )
+ // InternalOXtype.g:65:9: 'default'
+ {
+ match("default");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__67"
+
+ // $ANTLR start "T__68"
+ public final void mT__68() throws RecognitionException {
+ try {
+ int _type = T__68;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:66:7: ( 'case' )
+ // InternalOXtype.g:66:9: 'case'
+ {
+ match("case");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__68"
+
+ // $ANTLR start "T__69"
+ public final void mT__69() throws RecognitionException {
+ try {
+ int _type = T__69;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:67:7: ( 'for' )
+ // InternalOXtype.g:67:9: 'for'
+ {
+ match("for");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__69"
+
+ // $ANTLR start "T__70"
+ public final void mT__70() throws RecognitionException {
+ try {
+ int _type = T__70;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:68:7: ( 'while' )
+ // InternalOXtype.g:68:9: 'while'
+ {
+ match("while");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__70"
+
+ // $ANTLR start "T__71"
+ public final void mT__71() throws RecognitionException {
+ try {
+ int _type = T__71;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:69:7: ( 'do' )
+ // InternalOXtype.g:69:9: 'do'
+ {
+ match("do");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__71"
+
+ // $ANTLR start "T__72"
+ public final void mT__72() throws RecognitionException {
+ try {
+ int _type = T__72;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:70:7: ( 'var' )
+ // InternalOXtype.g:70:9: 'var'
+ {
+ match("var");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__72"
+
+ // $ANTLR start "T__73"
+ public final void mT__73() throws RecognitionException {
+ try {
+ int _type = T__73;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:71:7: ( 'val' )
+ // InternalOXtype.g:71:9: 'val'
+ {
+ match("val");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__73"
+
+ // $ANTLR start "T__74"
+ public final void mT__74() throws RecognitionException {
+ try {
+ int _type = T__74;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:72:7: ( 'extends' )
+ // InternalOXtype.g:72:9: 'extends'
+ {
+ match("extends");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__74"
+
+ // $ANTLR start "T__75"
+ public final void mT__75() throws RecognitionException {
+ try {
+ int _type = T__75;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:73:7: ( 'super' )
+ // InternalOXtype.g:73:9: 'super'
+ {
+ match("super");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__75"
+
+ // $ANTLR start "T__76"
+ public final void mT__76() throws RecognitionException {
+ try {
+ int _type = T__76;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:74:7: ( 'new' )
+ // InternalOXtype.g:74:9: 'new'
+ {
+ match("new");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__76"
+
+ // $ANTLR start "T__77"
+ public final void mT__77() throws RecognitionException {
+ try {
+ int _type = T__77;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:75:7: ( 'false' )
+ // InternalOXtype.g:75:9: 'false'
+ {
+ match("false");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__77"
+
+ // $ANTLR start "T__78"
+ public final void mT__78() throws RecognitionException {
+ try {
+ int _type = T__78;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:76:7: ( 'true' )
+ // InternalOXtype.g:76:9: 'true'
+ {
+ match("true");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__78"
+
+ // $ANTLR start "T__79"
+ public final void mT__79() throws RecognitionException {
+ try {
+ int _type = T__79;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:77:7: ( 'null' )
+ // InternalOXtype.g:77:9: 'null'
+ {
+ match("null");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__79"
+
+ // $ANTLR start "T__80"
+ public final void mT__80() throws RecognitionException {
+ try {
+ int _type = T__80;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:78:7: ( 'typeof' )
+ // InternalOXtype.g:78:9: 'typeof'
+ {
+ match("typeof");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__80"
+
+ // $ANTLR start "T__81"
+ public final void mT__81() throws RecognitionException {
+ try {
+ int _type = T__81;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:79:7: ( 'throw' )
+ // InternalOXtype.g:79:9: 'throw'
+ {
+ match("throw");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__81"
+
+ // $ANTLR start "T__82"
+ public final void mT__82() throws RecognitionException {
+ try {
+ int _type = T__82;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:80:7: ( 'return' )
+ // InternalOXtype.g:80:9: 'return'
+ {
+ match("return");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__82"
+
+ // $ANTLR start "T__83"
+ public final void mT__83() throws RecognitionException {
+ try {
+ int _type = T__83;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:81:7: ( 'try' )
+ // InternalOXtype.g:81:9: 'try'
+ {
+ match("try");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__83"
+
+ // $ANTLR start "T__84"
+ public final void mT__84() throws RecognitionException {
+ try {
+ int _type = T__84;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:82:7: ( 'finally' )
+ // InternalOXtype.g:82:9: 'finally'
+ {
+ match("finally");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__84"
+
+ // $ANTLR start "T__85"
+ public final void mT__85() throws RecognitionException {
+ try {
+ int _type = T__85;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:83:7: ( 'synchronized' )
+ // InternalOXtype.g:83:9: 'synchronized'
+ {
+ match("synchronized");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__85"
+
+ // $ANTLR start "T__86"
+ public final void mT__86() throws RecognitionException {
+ try {
+ int _type = T__86;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:84:7: ( 'catch' )
+ // InternalOXtype.g:84:9: 'catch'
+ {
+ match("catch");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__86"
+
+ // $ANTLR start "T__87"
+ public final void mT__87() throws RecognitionException {
+ try {
+ int _type = T__87;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:85:7: ( '?' )
+ // InternalOXtype.g:85:9: '?'
+ {
+ match('?');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__87"
+
+ // $ANTLR start "T__88"
+ public final void mT__88() throws RecognitionException {
+ try {
+ int _type = T__88;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:86:7: ( '&' )
+ // InternalOXtype.g:86:9: '&'
+ {
+ match('&');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__88"
+
+ // $ANTLR start "RULE_HEX"
+ public final void mRULE_HEX() throws RecognitionException {
+ try {
+ int _type = RULE_HEX;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:6888:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? )
+ // InternalOXtype.g:6888:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )?
+ {
+ // InternalOXtype.g:6888:12: ( '0x' | '0X' )
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( (LA1_0=='0') ) {
+ int LA1_1 = input.LA(2);
+
+ if ( (LA1_1=='x') ) {
+ alt1=1;
+ }
+ else if ( (LA1_1=='X') ) {
+ alt1=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 1, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 1, 0, input);
+
+ throw nvae;
+ }
+ switch (alt1) {
+ case 1 :
+ // InternalOXtype.g:6888:13: '0x'
+ {
+ match("0x");
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:6888:18: '0X'
+ {
+ match("0X");
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:6888:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+
+ int cnt2=0;
+ loop2:
+ do {
+ int alt2=2;
+ int LA2_0 = input.LA(1);
+
+ if ( ((LA2_0>='0' && LA2_0<='9')||(LA2_0>='A' && LA2_0<='F')||LA2_0=='_'||(LA2_0>='a' && LA2_0<='f')) ) {
+ alt2=1;
+ }
+
+
+ switch (alt2) {
+ case 1 :
+ // InternalOXtype.g:
+ {
+ if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='f') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ if ( cnt2 >= 1 ) break loop2;
+ EarlyExitException eee =
+ new EarlyExitException(2, input);
+ throw eee;
+ }
+ cnt2++;
+ } while (true);
+
+ // InternalOXtype.g:6888:58: ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )?
+ int alt4=2;
+ int LA4_0 = input.LA(1);
+
+ if ( (LA4_0=='#') ) {
+ alt4=1;
+ }
+ switch (alt4) {
+ case 1 :
+ // InternalOXtype.g:6888:59: '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) )
+ {
+ match('#');
+ // InternalOXtype.g:6888:63: ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) )
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( (LA3_0=='B'||LA3_0=='b') ) {
+ alt3=1;
+ }
+ else if ( (LA3_0=='L'||LA3_0=='l') ) {
+ alt3=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 3, 0, input);
+
+ throw nvae;
+ }
+ switch (alt3) {
+ case 1 :
+ // InternalOXtype.g:6888:64: ( 'b' | 'B' ) ( 'i' | 'I' )
+ {
+ if ( input.LA(1)=='B'||input.LA(1)=='b' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ if ( input.LA(1)=='I'||input.LA(1)=='i' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:6888:84: ( 'l' | 'L' )
+ {
+ if ( input.LA(1)=='L'||input.LA(1)=='l' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_HEX"
+
+ // $ANTLR start "RULE_INT"
+ public final void mRULE_INT() throws RecognitionException {
+ try {
+ int _type = RULE_INT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:6890:10: ( '0' .. '9' ( '0' .. '9' | '_' )* )
+ // InternalOXtype.g:6890:12: '0' .. '9' ( '0' .. '9' | '_' )*
+ {
+ matchRange('0','9');
+ // InternalOXtype.g:6890:21: ( '0' .. '9' | '_' )*
+ loop5:
+ do {
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( ((LA5_0>='0' && LA5_0<='9')||LA5_0=='_') ) {
+ alt5=1;
+ }
+
+
+ switch (alt5) {
+ case 1 :
+ // InternalOXtype.g:
+ {
+ if ( (input.LA(1)>='0' && input.LA(1)<='9')||input.LA(1)=='_' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop5;
+ }
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INT"
+
+ // $ANTLR start "RULE_DECIMAL"
+ public final void mRULE_DECIMAL() throws RecognitionException {
+ try {
+ int _type = RULE_DECIMAL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:6892:14: ( RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? )
+ // InternalOXtype.g:6892:16: RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )?
+ {
+ mRULE_INT();
+ // InternalOXtype.g:6892:25: ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )?
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( (LA7_0=='E'||LA7_0=='e') ) {
+ alt7=1;
+ }
+ switch (alt7) {
+ case 1 :
+ // InternalOXtype.g:6892:26: ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT
+ {
+ if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // InternalOXtype.g:6892:36: ( '+' | '-' )?
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( (LA6_0=='+'||LA6_0=='-') ) {
+ alt6=1;
+ }
+ switch (alt6) {
+ case 1 :
+ // InternalOXtype.g:
+ {
+ if ( input.LA(1)=='+'||input.LA(1)=='-' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ }
+
+ mRULE_INT();
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:6892:58: ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )?
+ int alt8=3;
+ int LA8_0 = input.LA(1);
+
+ if ( (LA8_0=='B'||LA8_0=='b') ) {
+ alt8=1;
+ }
+ else if ( (LA8_0=='D'||LA8_0=='F'||LA8_0=='L'||LA8_0=='d'||LA8_0=='f'||LA8_0=='l') ) {
+ alt8=2;
+ }
+ switch (alt8) {
+ case 1 :
+ // InternalOXtype.g:6892:59: ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' )
+ {
+ if ( input.LA(1)=='B'||input.LA(1)=='b' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ if ( input.LA(1)=='D'||input.LA(1)=='I'||input.LA(1)=='d'||input.LA(1)=='i' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:6892:87: ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' )
+ {
+ if ( input.LA(1)=='D'||input.LA(1)=='F'||input.LA(1)=='L'||input.LA(1)=='d'||input.LA(1)=='f'||input.LA(1)=='l' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_DECIMAL"
+
+ // $ANTLR start "RULE_ID"
+ public final void mRULE_ID() throws RecognitionException {
+ try {
+ int _type = RULE_ID;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:6894:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* )
+ // InternalOXtype.g:6894:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )*
+ {
+ // InternalOXtype.g:6894:11: ( '^' )?
+ int alt9=2;
+ int LA9_0 = input.LA(1);
+
+ if ( (LA9_0=='^') ) {
+ alt9=1;
+ }
+ switch (alt9) {
+ case 1 :
+ // InternalOXtype.g:6894:11: '^'
+ {
+ match('^');
+
+ }
+ break;
+
+ }
+
+ if ( input.LA(1)=='$'||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // InternalOXtype.g:6894:44: ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )*
+ loop10:
+ do {
+ int alt10=2;
+ int LA10_0 = input.LA(1);
+
+ if ( (LA10_0=='$'||(LA10_0>='0' && LA10_0<='9')||(LA10_0>='A' && LA10_0<='Z')||LA10_0=='_'||(LA10_0>='a' && LA10_0<='z')) ) {
+ alt10=1;
+ }
+
+
+ switch (alt10) {
+ case 1 :
+ // InternalOXtype.g:
+ {
+ if ( input.LA(1)=='$'||(input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop10;
+ }
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ID"
+
+ // $ANTLR start "RULE_STRING"
+ public final void mRULE_STRING() throws RecognitionException {
+ try {
+ int _type = RULE_STRING;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:6896:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) )
+ // InternalOXtype.g:6896:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? )
+ {
+ // InternalOXtype.g:6896:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? )
+ int alt15=2;
+ int LA15_0 = input.LA(1);
+
+ if ( (LA15_0=='\"') ) {
+ alt15=1;
+ }
+ else if ( (LA15_0=='\'') ) {
+ alt15=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 15, 0, input);
+
+ throw nvae;
+ }
+ switch (alt15) {
+ case 1 :
+ // InternalOXtype.g:6896:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )?
+ {
+ match('\"');
+ // InternalOXtype.g:6896:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
+ loop11:
+ do {
+ int alt11=3;
+ int LA11_0 = input.LA(1);
+
+ if ( (LA11_0=='\\') ) {
+ alt11=1;
+ }
+ else if ( ((LA11_0>='\u0000' && LA11_0<='!')||(LA11_0>='#' && LA11_0<='[')||(LA11_0>=']' && LA11_0<='\uFFFF')) ) {
+ alt11=2;
+ }
+
+
+ switch (alt11) {
+ case 1 :
+ // InternalOXtype.g:6896:21: '\\\\' .
+ {
+ match('\\');
+ matchAny();
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:6896:28: ~ ( ( '\\\\' | '\"' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop11;
+ }
+ } while (true);
+
+ // InternalOXtype.g:6896:44: ( '\"' )?
+ int alt12=2;
+ int LA12_0 = input.LA(1);
+
+ if ( (LA12_0=='\"') ) {
+ alt12=1;
+ }
+ switch (alt12) {
+ case 1 :
+ // InternalOXtype.g:6896:44: '\"'
+ {
+ match('\"');
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:6896:49: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )?
+ {
+ match('\'');
+ // InternalOXtype.g:6896:54: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )*
+ loop13:
+ do {
+ int alt13=3;
+ int LA13_0 = input.LA(1);
+
+ if ( (LA13_0=='\\') ) {
+ alt13=1;
+ }
+ else if ( ((LA13_0>='\u0000' && LA13_0<='&')||(LA13_0>='(' && LA13_0<='[')||(LA13_0>=']' && LA13_0<='\uFFFF')) ) {
+ alt13=2;
+ }
+
+
+ switch (alt13) {
+ case 1 :
+ // InternalOXtype.g:6896:55: '\\\\' .
+ {
+ match('\\');
+ matchAny();
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:6896:62: ~ ( ( '\\\\' | '\\'' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop13;
+ }
+ } while (true);
+
+ // InternalOXtype.g:6896:79: ( '\\'' )?
+ int alt14=2;
+ int LA14_0 = input.LA(1);
+
+ if ( (LA14_0=='\'') ) {
+ alt14=1;
+ }
+ switch (alt14) {
+ case 1 :
+ // InternalOXtype.g:6896:79: '\\''
+ {
+ match('\'');
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_STRING"
+
+ // $ANTLR start "RULE_ML_COMMENT"
+ public final void mRULE_ML_COMMENT() throws RecognitionException {
+ try {
+ int _type = RULE_ML_COMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:6898:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
+ // InternalOXtype.g:6898:19: '/*' ( options {greedy=false; } : . )* '*/'
+ {
+ match("/*");
+
+ // InternalOXtype.g:6898:24: ( options {greedy=false; } : . )*
+ loop16:
+ do {
+ int alt16=2;
+ int LA16_0 = input.LA(1);
+
+ if ( (LA16_0=='*') ) {
+ int LA16_1 = input.LA(2);
+
+ if ( (LA16_1=='/') ) {
+ alt16=2;
+ }
+ else if ( ((LA16_1>='\u0000' && LA16_1<='.')||(LA16_1>='0' && LA16_1<='\uFFFF')) ) {
+ alt16=1;
+ }
+
+
+ }
+ else if ( ((LA16_0>='\u0000' && LA16_0<=')')||(LA16_0>='+' && LA16_0<='\uFFFF')) ) {
+ alt16=1;
+ }
+
+
+ switch (alt16) {
+ case 1 :
+ // InternalOXtype.g:6898:52: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop16;
+ }
+ } while (true);
+
+ match("*/");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ML_COMMENT"
+
+ // $ANTLR start "RULE_SL_COMMENT"
+ public final void mRULE_SL_COMMENT() throws RecognitionException {
+ try {
+ int _type = RULE_SL_COMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:6900:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
+ // InternalOXtype.g:6900:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
+ {
+ match("//");
+
+ // InternalOXtype.g:6900:24: (~ ( ( '\\n' | '\\r' ) ) )*
+ loop17:
+ do {
+ int alt17=2;
+ int LA17_0 = input.LA(1);
+
+ if ( ((LA17_0>='\u0000' && LA17_0<='\t')||(LA17_0>='\u000B' && LA17_0<='\f')||(LA17_0>='\u000E' && LA17_0<='\uFFFF')) ) {
+ alt17=1;
+ }
+
+
+ switch (alt17) {
+ case 1 :
+ // InternalOXtype.g:6900:24: ~ ( ( '\\n' | '\\r' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop17;
+ }
+ } while (true);
+
+ // InternalOXtype.g:6900:40: ( ( '\\r' )? '\\n' )?
+ int alt19=2;
+ int LA19_0 = input.LA(1);
+
+ if ( (LA19_0=='\n'||LA19_0=='\r') ) {
+ alt19=1;
+ }
+ switch (alt19) {
+ case 1 :
+ // InternalOXtype.g:6900:41: ( '\\r' )? '\\n'
+ {
+ // InternalOXtype.g:6900:41: ( '\\r' )?
+ int alt18=2;
+ int LA18_0 = input.LA(1);
+
+ if ( (LA18_0=='\r') ) {
+ alt18=1;
+ }
+ switch (alt18) {
+ case 1 :
+ // InternalOXtype.g:6900:41: '\\r'
+ {
+ match('\r');
+
+ }
+ break;
+
+ }
+
+ match('\n');
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SL_COMMENT"
+
+ // $ANTLR start "RULE_WS"
+ public final void mRULE_WS() throws RecognitionException {
+ try {
+ int _type = RULE_WS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:6902:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
+ // InternalOXtype.g:6902:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+ {
+ // InternalOXtype.g:6902:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+ int cnt20=0;
+ loop20:
+ do {
+ int alt20=2;
+ int LA20_0 = input.LA(1);
+
+ if ( ((LA20_0>='\t' && LA20_0<='\n')||LA20_0=='\r'||LA20_0==' ') ) {
+ alt20=1;
+ }
+
+
+ switch (alt20) {
+ case 1 :
+ // InternalOXtype.g:
+ {
+ if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ if ( cnt20 >= 1 ) break loop20;
+ EarlyExitException eee =
+ new EarlyExitException(20, input);
+ throw eee;
+ }
+ cnt20++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_WS"
+
+ // $ANTLR start "RULE_ANY_OTHER"
+ public final void mRULE_ANY_OTHER() throws RecognitionException {
+ try {
+ int _type = RULE_ANY_OTHER;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalOXtype.g:6904:16: ( . )
+ // InternalOXtype.g:6904:18: .
+ {
+ matchAny();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ANY_OTHER"
+
+ public void mTokens() throws RecognitionException {
+ // InternalOXtype.g:1:8: ( T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER )
+ int alt21=85;
+ alt21 = dfa21.predict(input);
+ switch (alt21) {
+ case 1 :
+ // InternalOXtype.g:1:10: T__13
+ {
+ mT__13();
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:1:16: T__14
+ {
+ mT__14();
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:1:22: T__15
+ {
+ mT__15();
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:1:28: T__16
+ {
+ mT__16();
+
+ }
+ break;
+ case 5 :
+ // InternalOXtype.g:1:34: T__17
+ {
+ mT__17();
+
+ }
+ break;
+ case 6 :
+ // InternalOXtype.g:1:40: T__18
+ {
+ mT__18();
+
+ }
+ break;
+ case 7 :
+ // InternalOXtype.g:1:46: T__19
+ {
+ mT__19();
+
+ }
+ break;
+ case 8 :
+ // InternalOXtype.g:1:52: T__20
+ {
+ mT__20();
+
+ }
+ break;
+ case 9 :
+ // InternalOXtype.g:1:58: T__21
+ {
+ mT__21();
+
+ }
+ break;
+ case 10 :
+ // InternalOXtype.g:1:64: T__22
+ {
+ mT__22();
+
+ }
+ break;
+ case 11 :
+ // InternalOXtype.g:1:70: T__23
+ {
+ mT__23();
+
+ }
+ break;
+ case 12 :
+ // InternalOXtype.g:1:76: T__24
+ {
+ mT__24();
+
+ }
+ break;
+ case 13 :
+ // InternalOXtype.g:1:82: T__25
+ {
+ mT__25();
+
+ }
+ break;
+ case 14 :
+ // InternalOXtype.g:1:88: T__26
+ {
+ mT__26();
+
+ }
+ break;
+ case 15 :
+ // InternalOXtype.g:1:94: T__27
+ {
+ mT__27();
+
+ }
+ break;
+ case 16 :
+ // InternalOXtype.g:1:100: T__28
+ {
+ mT__28();
+
+ }
+ break;
+ case 17 :
+ // InternalOXtype.g:1:106: T__29
+ {
+ mT__29();
+
+ }
+ break;
+ case 18 :
+ // InternalOXtype.g:1:112: T__30
+ {
+ mT__30();
+
+ }
+ break;
+ case 19 :
+ // InternalOXtype.g:1:118: T__31
+ {
+ mT__31();
+
+ }
+ break;
+ case 20 :
+ // InternalOXtype.g:1:124: T__32
+ {
+ mT__32();
+
+ }
+ break;
+ case 21 :
+ // InternalOXtype.g:1:130: T__33
+ {
+ mT__33();
+
+ }
+ break;
+ case 22 :
+ // InternalOXtype.g:1:136: T__34
+ {
+ mT__34();
+
+ }
+ break;
+ case 23 :
+ // InternalOXtype.g:1:142: T__35
+ {
+ mT__35();
+
+ }
+ break;
+ case 24 :
+ // InternalOXtype.g:1:148: T__36
+ {
+ mT__36();
+
+ }
+ break;
+ case 25 :
+ // InternalOXtype.g:1:154: T__37
+ {
+ mT__37();
+
+ }
+ break;
+ case 26 :
+ // InternalOXtype.g:1:160: T__38
+ {
+ mT__38();
+
+ }
+ break;
+ case 27 :
+ // InternalOXtype.g:1:166: T__39
+ {
+ mT__39();
+
+ }
+ break;
+ case 28 :
+ // InternalOXtype.g:1:172: T__40
+ {
+ mT__40();
+
+ }
+ break;
+ case 29 :
+ // InternalOXtype.g:1:178: T__41
+ {
+ mT__41();
+
+ }
+ break;
+ case 30 :
+ // InternalOXtype.g:1:184: T__42
+ {
+ mT__42();
+
+ }
+ break;
+ case 31 :
+ // InternalOXtype.g:1:190: T__43
+ {
+ mT__43();
+
+ }
+ break;
+ case 32 :
+ // InternalOXtype.g:1:196: T__44
+ {
+ mT__44();
+
+ }
+ break;
+ case 33 :
+ // InternalOXtype.g:1:202: T__45
+ {
+ mT__45();
+
+ }
+ break;
+ case 34 :
+ // InternalOXtype.g:1:208: T__46
+ {
+ mT__46();
+
+ }
+ break;
+ case 35 :
+ // InternalOXtype.g:1:214: T__47
+ {
+ mT__47();
+
+ }
+ break;
+ case 36 :
+ // InternalOXtype.g:1:220: T__48
+ {
+ mT__48();
+
+ }
+ break;
+ case 37 :
+ // InternalOXtype.g:1:226: T__49
+ {
+ mT__49();
+
+ }
+ break;
+ case 38 :
+ // InternalOXtype.g:1:232: T__50
+ {
+ mT__50();
+
+ }
+ break;
+ case 39 :
+ // InternalOXtype.g:1:238: T__51
+ {
+ mT__51();
+
+ }
+ break;
+ case 40 :
+ // InternalOXtype.g:1:244: T__52
+ {
+ mT__52();
+
+ }
+ break;
+ case 41 :
+ // InternalOXtype.g:1:250: T__53
+ {
+ mT__53();
+
+ }
+ break;
+ case 42 :
+ // InternalOXtype.g:1:256: T__54
+ {
+ mT__54();
+
+ }
+ break;
+ case 43 :
+ // InternalOXtype.g:1:262: T__55
+ {
+ mT__55();
+
+ }
+ break;
+ case 44 :
+ // InternalOXtype.g:1:268: T__56
+ {
+ mT__56();
+
+ }
+ break;
+ case 45 :
+ // InternalOXtype.g:1:274: T__57
+ {
+ mT__57();
+
+ }
+ break;
+ case 46 :
+ // InternalOXtype.g:1:280: T__58
+ {
+ mT__58();
+
+ }
+ break;
+ case 47 :
+ // InternalOXtype.g:1:286: T__59
+ {
+ mT__59();
+
+ }
+ break;
+ case 48 :
+ // InternalOXtype.g:1:292: T__60
+ {
+ mT__60();
+
+ }
+ break;
+ case 49 :
+ // InternalOXtype.g:1:298: T__61
+ {
+ mT__61();
+
+ }
+ break;
+ case 50 :
+ // InternalOXtype.g:1:304: T__62
+ {
+ mT__62();
+
+ }
+ break;
+ case 51 :
+ // InternalOXtype.g:1:310: T__63
+ {
+ mT__63();
+
+ }
+ break;
+ case 52 :
+ // InternalOXtype.g:1:316: T__64
+ {
+ mT__64();
+
+ }
+ break;
+ case 53 :
+ // InternalOXtype.g:1:322: T__65
+ {
+ mT__65();
+
+ }
+ break;
+ case 54 :
+ // InternalOXtype.g:1:328: T__66
+ {
+ mT__66();
+
+ }
+ break;
+ case 55 :
+ // InternalOXtype.g:1:334: T__67
+ {
+ mT__67();
+
+ }
+ break;
+ case 56 :
+ // InternalOXtype.g:1:340: T__68
+ {
+ mT__68();
+
+ }
+ break;
+ case 57 :
+ // InternalOXtype.g:1:346: T__69
+ {
+ mT__69();
+
+ }
+ break;
+ case 58 :
+ // InternalOXtype.g:1:352: T__70
+ {
+ mT__70();
+
+ }
+ break;
+ case 59 :
+ // InternalOXtype.g:1:358: T__71
+ {
+ mT__71();
+
+ }
+ break;
+ case 60 :
+ // InternalOXtype.g:1:364: T__72
+ {
+ mT__72();
+
+ }
+ break;
+ case 61 :
+ // InternalOXtype.g:1:370: T__73
+ {
+ mT__73();
+
+ }
+ break;
+ case 62 :
+ // InternalOXtype.g:1:376: T__74
+ {
+ mT__74();
+
+ }
+ break;
+ case 63 :
+ // InternalOXtype.g:1:382: T__75
+ {
+ mT__75();
+
+ }
+ break;
+ case 64 :
+ // InternalOXtype.g:1:388: T__76
+ {
+ mT__76();
+
+ }
+ break;
+ case 65 :
+ // InternalOXtype.g:1:394: T__77
+ {
+ mT__77();
+
+ }
+ break;
+ case 66 :
+ // InternalOXtype.g:1:400: T__78
+ {
+ mT__78();
+
+ }
+ break;
+ case 67 :
+ // InternalOXtype.g:1:406: T__79
+ {
+ mT__79();
+
+ }
+ break;
+ case 68 :
+ // InternalOXtype.g:1:412: T__80
+ {
+ mT__80();
+
+ }
+ break;
+ case 69 :
+ // InternalOXtype.g:1:418: T__81
+ {
+ mT__81();
+
+ }
+ break;
+ case 70 :
+ // InternalOXtype.g:1:424: T__82
+ {
+ mT__82();
+
+ }
+ break;
+ case 71 :
+ // InternalOXtype.g:1:430: T__83
+ {
+ mT__83();
+
+ }
+ break;
+ case 72 :
+ // InternalOXtype.g:1:436: T__84
+ {
+ mT__84();
+
+ }
+ break;
+ case 73 :
+ // InternalOXtype.g:1:442: T__85
+ {
+ mT__85();
+
+ }
+ break;
+ case 74 :
+ // InternalOXtype.g:1:448: T__86
+ {
+ mT__86();
+
+ }
+ break;
+ case 75 :
+ // InternalOXtype.g:1:454: T__87
+ {
+ mT__87();
+
+ }
+ break;
+ case 76 :
+ // InternalOXtype.g:1:460: T__88
+ {
+ mT__88();
+
+ }
+ break;
+ case 77 :
+ // InternalOXtype.g:1:466: RULE_HEX
+ {
+ mRULE_HEX();
+
+ }
+ break;
+ case 78 :
+ // InternalOXtype.g:1:475: RULE_INT
+ {
+ mRULE_INT();
+
+ }
+ break;
+ case 79 :
+ // InternalOXtype.g:1:484: RULE_DECIMAL
+ {
+ mRULE_DECIMAL();
+
+ }
+ break;
+ case 80 :
+ // InternalOXtype.g:1:497: RULE_ID
+ {
+ mRULE_ID();
+
+ }
+ break;
+ case 81 :
+ // InternalOXtype.g:1:505: RULE_STRING
+ {
+ mRULE_STRING();
+
+ }
+ break;
+ case 82 :
+ // InternalOXtype.g:1:517: RULE_ML_COMMENT
+ {
+ mRULE_ML_COMMENT();
+
+ }
+ break;
+ case 83 :
+ // InternalOXtype.g:1:533: RULE_SL_COMMENT
+ {
+ mRULE_SL_COMMENT();
+
+ }
+ break;
+ case 84 :
+ // InternalOXtype.g:1:549: RULE_WS
+ {
+ mRULE_WS();
+
+ }
+ break;
+ case 85 :
+ // InternalOXtype.g:1:557: RULE_ANY_OTHER
+ {
+ mRULE_ANY_OTHER();
+
+ }
+ break;
+
+ }
+
+ }
+
+
+ protected DFA21 dfa21 = new DFA21(this);
+ static final String DFA21_eotS =
+ "\1\uffff\3\60\1\71\1\60\5\uffff\1\104\3\uffff\1\112\1\116\1\122\1\124\1\126\1\130\1\132\1\134\1\136\1\140\1\143\1\60\1\146\2\uffff\7\60\2\167\1\54\5\uffff\2\60\1\175\1\uffff\6\60\3\uffff\1\u0084\2\60\5\uffff\1\u0088\32\uffff\1\u008a\1\uffff\1\u008c\4\uffff\1\u008d\4\uffff\1\60\1\u008f\12\60\1\uffff\1\167\4\uffff\2\60\1\uffff\6\60\1\uffff\1\u00a5\1\60\7\uffff\1\60\1\uffff\2\60\1\u00aa\3\60\1\u00ae\1\u00af\1\60\1\u00b1\12\60\1\u00bc\1\uffff\1\u00bd\1\60\1\u00bf\1\60\1\uffff\3\60\2\uffff\1\u00c4\1\uffff\7\60\1\u00cc\2\60\2\uffff\1\60\1\uffff\1\u00d1\1\u00d2\1\60\1\u00d4\1\uffff\1\60\1\u00d6\1\60\1\u00d8\1\60\1\u00da\1\u00db\1\uffff\4\60\2\uffff\1\60\1\uffff\1\u00e1\1\uffff\1\u00e2\1\uffff\1\60\2\uffff\2\60\1\u00e6\1\u00e7\1\u00e8\2\uffff\3\60\3\uffff\2\60\1\u00ee\1\u00ef\1\60\2\uffff\1\60\1\u00f2\1\uffff";
+ static final String DFA21_eofS =
+ "\u00f3\uffff";
+ static final String DFA21_minS =
+ "\1\0\1\146\1\164\1\154\1\52\1\145\5\uffff\1\75\3\uffff\1\53\1\55\1\52\1\75\1\76\1\75\1\174\1\46\1\75\2\56\1\163\1\72\2\uffff\1\145\2\141\1\150\1\141\1\150\1\145\2\60\1\44\5\uffff\1\160\1\163\1\44\1\uffff\1\141\1\151\1\160\1\156\1\164\1\163\3\uffff\1\44\1\167\1\154\5\uffff\1\75\32\uffff\1\75\1\uffff\1\74\4\uffff\1\44\4\uffff\1\146\1\44\1\163\1\162\1\154\1\156\1\151\1\154\1\165\1\160\1\162\1\164\1\uffff\1\60\4\uffff\1\157\1\164\1\uffff\2\164\1\145\1\143\2\145\1\uffff\1\44\1\154\7\uffff\1\141\1\uffff\1\145\1\143\1\44\1\163\1\141\1\154\2\44\1\145\1\44\1\145\1\157\1\165\1\162\1\141\1\151\1\143\1\162\1\150\1\156\1\44\1\uffff\1\44\1\165\1\44\1\150\1\uffff\1\145\1\154\1\145\2\uffff\1\44\1\uffff\1\157\1\167\1\162\1\164\1\156\1\143\1\150\1\44\1\162\1\144\2\uffff\1\154\1\uffff\2\44\1\154\1\44\1\uffff\1\146\1\44\1\156\1\44\1\143\2\44\1\uffff\1\157\1\151\1\163\1\164\2\uffff\1\171\1\uffff\1\44\1\uffff\1\44\1\uffff\1\145\2\uffff\1\156\1\157\3\44\2\uffff\1\157\1\151\1\156\3\uffff\1\146\1\172\2\44\1\145\2\uffff\1\144\1\44\1\uffff";
+ static final String DFA21_maxS =
+ "\1\uffff\1\156\1\171\1\170\1\75\1\165\5\uffff\1\76\3\uffff\1\75\1\76\2\75\1\76\1\75\1\174\1\46\1\75\1\56\1\72\1\163\1\72\2\uffff\1\157\1\141\1\157\1\150\1\141\1\171\1\145\1\170\1\154\1\172\5\uffff\1\160\1\163\1\172\1\uffff\1\141\1\151\1\160\1\156\1\164\1\163\3\uffff\1\172\1\167\1\154\5\uffff\1\75\32\uffff\1\75\1\uffff\1\74\4\uffff\1\172\4\uffff\1\146\1\172\1\164\1\162\1\154\1\156\1\151\1\162\1\171\1\160\1\162\1\164\1\uffff\1\154\4\uffff\1\157\1\164\1\uffff\2\164\1\145\1\143\2\145\1\uffff\1\172\1\154\7\uffff\1\141\1\uffff\1\145\1\143\1\172\1\163\1\141\1\154\2\172\1\145\1\172\1\145\1\157\1\165\1\162\1\141\1\151\1\143\1\162\1\150\1\156\1\172\1\uffff\1\172\1\165\1\172\1\150\1\uffff\1\145\1\154\1\145\2\uffff\1\172\1\uffff\1\157\1\167\1\162\1\164\1\156\1\143\1\150\1\172\1\162\1\163\2\uffff\1\154\1\uffff\2\172\1\154\1\172\1\uffff\1\146\1\172\1\156\1\172\1\143\2\172\1\uffff\1\157\1\151\1\163\1\164\2\uffff\1\171\1\uffff\1\172\1\uffff\1\172\1\uffff\1\145\2\uffff\1\156\1\157\3\172\2\uffff\1\157\1\151\1\156\3\uffff\1\146\3\172\1\145\2\uffff\1\144\1\172\1\uffff";
+ static final String DFA21_acceptS =
+ "\6\uffff\1\6\1\7\1\10\1\11\1\12\1\uffff\1\14\1\15\1\16\15\uffff\1\60\1\61\12\uffff\1\120\2\121\1\124\1\125\3\uffff\1\120\6\uffff\1\21\1\46\1\4\3\uffff\1\6\1\7\1\10\1\11\1\12\1\uffff\1\41\1\13\1\14\1\15\1\16\1\17\1\53\1\44\1\20\1\36\1\54\1\45\1\22\1\122\1\123\1\47\1\23\1\50\1\42\1\24\1\26\1\25\1\27\1\62\1\30\1\114\1\uffff\1\51\1\uffff\1\55\1\43\1\57\1\113\1\uffff\1\56\1\66\1\60\1\61\14\uffff\1\115\1\uffff\1\116\1\117\1\121\1\124\2\uffff\1\63\6\uffff\1\5\2\uffff\1\33\1\31\1\34\1\32\1\37\1\40\1\52\1\uffff\1\73\25\uffff\1\100\4\uffff\1\71\3\uffff\1\74\1\75\1\uffff\1\107\12\uffff\1\64\1\103\1\uffff\1\70\4\uffff\1\102\7\uffff\1\77\4\uffff\1\112\1\101\1\uffff\1\72\1\uffff\1\105\1\uffff\1\1\1\uffff\1\2\1\65\5\uffff\1\104\1\106\3\uffff\1\76\1\67\1\110\5\uffff\1\3\1\35\2\uffff\1\111";
+ static final String DFA21_specialS =
+ "\1\0\u00f2\uffff}>";
+ static final String[] DFA21_transitionS = {
+ "\11\54\2\53\2\54\1\53\22\54\1\53\1\27\1\51\1\14\1\50\1\22\1\26\1\52\1\10\1\12\1\4\1\17\1\11\1\20\1\30\1\21\1\45\11\46\1\33\1\6\1\23\1\13\1\24\1\31\1\7\32\50\1\15\1\54\1\16\1\47\1\50\1\54\1\32\1\50\1\37\1\36\1\3\1\40\2\50\1\1\4\50\1\5\3\50\1\44\1\2\1\43\1\50\1\42\1\41\3\50\1\34\1\25\1\35\uff82\54",
+ "\1\57\6\uffff\1\55\1\56",
+ "\1\61\1\63\1\uffff\1\62\1\uffff\1\64",
+ "\1\66\13\uffff\1\65",
+ "\1\70\22\uffff\1\67",
+ "\1\73\15\uffff\1\72\1\uffff\1\74",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\102\1\103",
+ "",
+ "",
+ "",
+ "\1\111\21\uffff\1\110",
+ "\1\115\17\uffff\1\113\1\114",
+ "\1\120\4\uffff\1\121\15\uffff\1\117",
+ "\1\123",
+ "\1\125",
+ "\1\127",
+ "\1\131",
+ "\1\133",
+ "\1\135",
+ "\1\137",
+ "\1\142\13\uffff\1\141",
+ "\1\144",
+ "\1\145",
+ "",
+ "",
+ "\1\151\11\uffff\1\152",
+ "\1\153",
+ "\1\155\7\uffff\1\156\5\uffff\1\154",
+ "\1\157",
+ "\1\160",
+ "\1\163\11\uffff\1\161\6\uffff\1\162",
+ "\1\164",
+ "\12\166\10\uffff\1\170\1\uffff\3\170\5\uffff\1\170\13\uffff\1\165\6\uffff\1\166\2\uffff\1\170\1\uffff\3\170\5\uffff\1\170\13\uffff\1\165",
+ "\12\166\10\uffff\1\170\1\uffff\3\170\5\uffff\1\170\22\uffff\1\166\2\uffff\1\170\1\uffff\3\170\5\uffff\1\170",
+ "\1\60\34\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\173",
+ "\1\174",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "",
+ "\1\176",
+ "\1\177",
+ "\1\u0080",
+ "\1\u0081",
+ "\1\u0082",
+ "\1\u0083",
+ "",
+ "",
+ "",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\u0085",
+ "\1\u0086",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\u0087",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\u0089",
+ "",
+ "\1\u008b",
+ "",
+ "",
+ "",
+ "",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "",
+ "",
+ "",
+ "",
+ "\1\u008e",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\u0090\1\u0091",
+ "\1\u0092",
+ "\1\u0093",
+ "\1\u0094",
+ "\1\u0095",
+ "\1\u0097\5\uffff\1\u0096",
+ "\1\u0098\3\uffff\1\u0099",
+ "\1\u009a",
+ "\1\u009b",
+ "\1\u009c",
+ "",
+ "\12\166\10\uffff\1\170\1\uffff\3\170\5\uffff\1\170\22\uffff\1\166\2\uffff\1\170\1\uffff\3\170\5\uffff\1\170",
+ "",
+ "",
+ "",
+ "",
+ "\1\u009d",
+ "\1\u009e",
+ "",
+ "\1\u009f",
+ "\1\u00a0",
+ "\1\u00a1",
+ "\1\u00a2",
+ "\1\u00a3",
+ "\1\u00a4",
+ "",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\u00a6",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\u00a7",
+ "",
+ "\1\u00a8",
+ "\1\u00a9",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\u00ab",
+ "\1\u00ac",
+ "\1\u00ad",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\u00b0",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\u00b2",
+ "\1\u00b3",
+ "\1\u00b4",
+ "\1\u00b5",
+ "\1\u00b6",
+ "\1\u00b7",
+ "\1\u00b8",
+ "\1\u00b9",
+ "\1\u00ba",
+ "\1\u00bb",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\u00be",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\u00c0",
+ "",
+ "\1\u00c1",
+ "\1\u00c2",
+ "\1\u00c3",
+ "",
+ "",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "",
+ "\1\u00c5",
+ "\1\u00c6",
+ "\1\u00c7",
+ "\1\u00c8",
+ "\1\u00c9",
+ "\1\u00ca",
+ "\1\u00cb",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\u00cd",
+ "\1\u00cf\16\uffff\1\u00ce",
+ "",
+ "",
+ "\1\u00d0",
+ "",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\u00d3",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "",
+ "\1\u00d5",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\u00d7",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\u00d9",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "",
+ "\1\u00dc",
+ "\1\u00dd",
+ "\1\u00de",
+ "\1\u00df",
+ "",
+ "",
+ "\1\u00e0",
+ "",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "",
+ "\1\u00e3",
+ "",
+ "",
+ "\1\u00e4",
+ "\1\u00e5",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "",
+ "",
+ "\1\u00e9",
+ "\1\u00ea",
+ "\1\u00eb",
+ "",
+ "",
+ "",
+ "\1\u00ec",
+ "\1\u00ed",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ "\1\u00f0",
+ "",
+ "",
+ "\1\u00f1",
+ "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+ ""
+ };
+
+ static final short[] DFA21_eot = DFA.unpackEncodedString(DFA21_eotS);
+ static final short[] DFA21_eof = DFA.unpackEncodedString(DFA21_eofS);
+ static final char[] DFA21_min = DFA.unpackEncodedStringToUnsignedChars(DFA21_minS);
+ static final char[] DFA21_max = DFA.unpackEncodedStringToUnsignedChars(DFA21_maxS);
+ static final short[] DFA21_accept = DFA.unpackEncodedString(DFA21_acceptS);
+ static final short[] DFA21_special = DFA.unpackEncodedString(DFA21_specialS);
+ static final short[][] DFA21_transition;
+
+ static {
+ int numStates = DFA21_transitionS.length;
+ DFA21_transition = new short[numStates][];
+ for (int i=0; i<numStates; i++) {
+ DFA21_transition[i] = DFA.unpackEncodedString(DFA21_transitionS[i]);
+ }
+ }
+
+ class DFA21 extends DFA {
+
+ public DFA21(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 21;
+ this.eot = DFA21_eot;
+ this.eof = DFA21_eof;
+ this.min = DFA21_min;
+ this.max = DFA21_max;
+ this.accept = DFA21_accept;
+ this.special = DFA21_special;
+ this.transition = DFA21_transition;
+ }
+ public String getDescription() {
+ return "1:1: Tokens : ( T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER );";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ IntStream input = _input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA21_0 = input.LA(1);
+
+ s = -1;
+ if ( (LA21_0=='i') ) {s = 1;}
+
+ else if ( (LA21_0=='s') ) {s = 2;}
+
+ else if ( (LA21_0=='e') ) {s = 3;}
+
+ else if ( (LA21_0=='*') ) {s = 4;}
+
+ else if ( (LA21_0=='n') ) {s = 5;}
+
+ else if ( (LA21_0==';') ) {s = 6;}
+
+ else if ( (LA21_0=='@') ) {s = 7;}
+
+ else if ( (LA21_0=='(') ) {s = 8;}
+
+ else if ( (LA21_0==',') ) {s = 9;}
+
+ else if ( (LA21_0==')') ) {s = 10;}
+
+ else if ( (LA21_0=='=') ) {s = 11;}
+
+ else if ( (LA21_0=='#') ) {s = 12;}
+
+ else if ( (LA21_0=='[') ) {s = 13;}
+
+ else if ( (LA21_0==']') ) {s = 14;}
+
+ else if ( (LA21_0=='+') ) {s = 15;}
+
+ else if ( (LA21_0=='-') ) {s = 16;}
+
+ else if ( (LA21_0=='/') ) {s = 17;}
+
+ else if ( (LA21_0=='%') ) {s = 18;}
+
+ else if ( (LA21_0=='<') ) {s = 19;}
+
+ else if ( (LA21_0=='>') ) {s = 20;}
+
+ else if ( (LA21_0=='|') ) {s = 21;}
+
+ else if ( (LA21_0=='&') ) {s = 22;}
+
+ else if ( (LA21_0=='!') ) {s = 23;}
+
+ else if ( (LA21_0=='.') ) {s = 24;}
+
+ else if ( (LA21_0=='?') ) {s = 25;}
+
+ else if ( (LA21_0=='a') ) {s = 26;}
+
+ else if ( (LA21_0==':') ) {s = 27;}
+
+ else if ( (LA21_0=='{') ) {s = 28;}
+
+ else if ( (LA21_0=='}') ) {s = 29;}
+
+ else if ( (LA21_0=='d') ) {s = 30;}
+
+ else if ( (LA21_0=='c') ) {s = 31;}
+
+ else if ( (LA21_0=='f') ) {s = 32;}
+
+ else if ( (LA21_0=='w') ) {s = 33;}
+
+ else if ( (LA21_0=='v') ) {s = 34;}
+
+ else if ( (LA21_0=='t') ) {s = 35;}
+
+ else if ( (LA21_0=='r') ) {s = 36;}
+
+ else if ( (LA21_0=='0') ) {s = 37;}
+
+ else if ( ((LA21_0>='1' && LA21_0<='9')) ) {s = 38;}
+
+ else if ( (LA21_0=='^') ) {s = 39;}
+
+ else if ( (LA21_0=='$'||(LA21_0>='A' && LA21_0<='Z')||LA21_0=='_'||LA21_0=='b'||(LA21_0>='g' && LA21_0<='h')||(LA21_0>='j' && LA21_0<='m')||(LA21_0>='o' && LA21_0<='q')||LA21_0=='u'||(LA21_0>='x' && LA21_0<='z')) ) {s = 40;}
+
+ else if ( (LA21_0=='\"') ) {s = 41;}
+
+ else if ( (LA21_0=='\'') ) {s = 42;}
+
+ else if ( ((LA21_0>='\t' && LA21_0<='\n')||LA21_0=='\r'||LA21_0==' ') ) {s = 43;}
+
+ else if ( ((LA21_0>='\u0000' && LA21_0<='\b')||(LA21_0>='\u000B' && LA21_0<='\f')||(LA21_0>='\u000E' && LA21_0<='\u001F')||LA21_0=='\\'||LA21_0=='`'||(LA21_0>='~' && LA21_0<='\uFFFF')) ) {s = 44;}
+
+ if ( s>=0 ) return s;
+ break;
+ }
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 21, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtypeParser.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtypeParser.java
new file mode 100644
index 0000000..e30de50
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtypeParser.java
@@ -0,0 +1,24135 @@
+package org.eclipse.osbp.xtext.oxtype.parser.antlr.internal;
+
+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.AbstractInternalAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+@SuppressWarnings("all")
+public class InternalOXtypeParser extends AbstractInternalAntlrParser {
+ public static final String[] tokenNames = new String[] {
+ "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_STRING", "RULE_HEX", "RULE_INT", "RULE_DECIMAL", "RULE_ID", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'import'", "'static'", "'extension'", "'*'", "'ns'", "';'", "'@'", "'('", "','", "')'", "'='", "'#'", "'['", "']'", "'+='", "'-='", "'*='", "'/='", "'%='", "'<'", "'>'", "'>='", "'||'", "'&&'", "'=='", "'!='", "'==='", "'!=='", "'instanceof'", "'->'", "'..<'", "'..'", "'=>'", "'<>'", "'?:'", "'+'", "'-'", "'**'", "'/'", "'%'", "'!'", "'as'", "'++'", "'--'", "'.'", "'::'", "'?.'", "'{'", "'}'", "'|'", "'if'", "'else'", "'switch'", "':'", "'default'", "'case'", "'for'", "'while'", "'do'", "'var'", "'val'", "'extends'", "'super'", "'new'", "'false'", "'true'", "'null'", "'typeof'", "'throw'", "'return'", "'try'", "'finally'", "'synchronized'", "'catch'", "'?'", "'&'"
+ };
+ public static final int RULE_HEX=5;
+ public static final int T__50=50;
+ public static final int T__19=19;
+ public static final int T__15=15;
+ public static final int T__59=59;
+ public static final int T__16=16;
+ public static final int T__17=17;
+ public static final int T__18=18;
+ public static final int T__55=55;
+ public static final int T__56=56;
+ public static final int T__13=13;
+ public static final int T__57=57;
+ public static final int T__14=14;
+ public static final int T__58=58;
+ public static final int T__51=51;
+ public static final int T__52=52;
+ public static final int T__53=53;
+ public static final int T__54=54;
+ public static final int T__60=60;
+ public static final int T__61=61;
+ public static final int RULE_ID=8;
+ public static final int RULE_DECIMAL=7;
+ public static final int T__26=26;
+ public static final int T__27=27;
+ public static final int T__28=28;
+ public static final int RULE_INT=6;
+ public static final int T__29=29;
+ public static final int T__22=22;
+ public static final int T__66=66;
+ public static final int RULE_ML_COMMENT=9;
+ public static final int T__23=23;
+ public static final int T__67=67;
+ public static final int T__24=24;
+ public static final int T__68=68;
+ public static final int T__25=25;
+ public static final int T__69=69;
+ public static final int T__62=62;
+ public static final int T__63=63;
+ public static final int T__20=20;
+ public static final int T__64=64;
+ public static final int T__21=21;
+ public static final int T__65=65;
+ public static final int T__70=70;
+ public static final int T__71=71;
+ public static final int T__72=72;
+ public static final int RULE_STRING=4;
+ public static final int RULE_SL_COMMENT=10;
+ public static final int T__37=37;
+ public static final int T__38=38;
+ public static final int T__39=39;
+ public static final int T__33=33;
+ public static final int T__77=77;
+ public static final int T__34=34;
+ public static final int T__78=78;
+ public static final int T__35=35;
+ public static final int T__79=79;
+ public static final int T__36=36;
+ public static final int T__73=73;
+ public static final int EOF=-1;
+ public static final int T__30=30;
+ public static final int T__74=74;
+ public static final int T__31=31;
+ public static final int T__75=75;
+ public static final int T__32=32;
+ public static final int T__76=76;
+ public static final int T__80=80;
+ public static final int T__81=81;
+ public static final int T__82=82;
+ public static final int T__83=83;
+ public static final int RULE_WS=11;
+ public static final int RULE_ANY_OTHER=12;
+ public static final int T__48=48;
+ public static final int T__49=49;
+ public static final int T__44=44;
+ public static final int T__88=88;
+ public static final int T__45=45;
+ public static final int T__46=46;
+ public static final int T__47=47;
+ public static final int T__40=40;
+ public static final int T__84=84;
+ public static final int T__41=41;
+ public static final int T__85=85;
+ public static final int T__42=42;
+ public static final int T__86=86;
+ public static final int T__43=43;
+ public static final int T__87=87;
+
+ // delegates
+ // delegators
+
+
+ public InternalOXtypeParser(TokenStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public InternalOXtypeParser(TokenStream input, RecognizerSharedState state) {
+ super(input, state);
+
+ }
+
+
+ public String[] getTokenNames() { return InternalOXtypeParser.tokenNames; }
+ public String getGrammarFileName() { return "InternalOXtype.g"; }
+
+
+
+ private OXtypeGrammarAccess grammarAccess;
+
+ public InternalOXtypeParser(TokenStream input, OXtypeGrammarAccess grammarAccess) {
+ this(input);
+ this.grammarAccess = grammarAccess;
+ registerRules(grammarAccess.getGrammar());
+ }
+
+ @Override
+ protected String getFirstRuleName() {
+ return "XImportDeclaration";
+ }
+
+ @Override
+ protected OXtypeGrammarAccess getGrammarAccess() {
+ return grammarAccess;
+ }
+
+
+
+
+ // $ANTLR start "entryRuleXImportDeclaration"
+ // InternalOXtype.g:64:1: entryRuleXImportDeclaration returns [EObject current=null] : iv_ruleXImportDeclaration= ruleXImportDeclaration EOF ;
+ public final EObject entryRuleXImportDeclaration() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXImportDeclaration = null;
+
+
+ try {
+ // InternalOXtype.g:64:59: (iv_ruleXImportDeclaration= ruleXImportDeclaration EOF )
+ // InternalOXtype.g:65:2: iv_ruleXImportDeclaration= ruleXImportDeclaration EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXImportDeclarationRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXImportDeclaration=ruleXImportDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXImportDeclaration;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXImportDeclaration"
+
+
+ // $ANTLR start "ruleXImportDeclaration"
+ // InternalOXtype.g:71:1: ruleXImportDeclaration returns [EObject current=null] : ( () otherlv_1= 'import' ( ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) ) | ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) ) ) (otherlv_11= ';' )? ) ;
+ public final EObject ruleXImportDeclaration() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token lv_static_2_0=null;
+ Token lv_extension_3_0=null;
+ Token lv_wildcard_5_0=null;
+ Token lv_fqnImport_9_0=null;
+ Token otherlv_11=null;
+ AntlrDatatypeRuleToken lv_memberName_6_0 = null;
+
+ AntlrDatatypeRuleToken lv_importedNamespace_8_0 = null;
+
+ AntlrDatatypeRuleToken lv_importedFullyQualifiedName_10_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:77:2: ( ( () otherlv_1= 'import' ( ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) ) | ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) ) ) (otherlv_11= ';' )? ) )
+ // InternalOXtype.g:78:2: ( () otherlv_1= 'import' ( ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) ) | ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) ) ) (otherlv_11= ';' )? )
+ {
+ // InternalOXtype.g:78:2: ( () otherlv_1= 'import' ( ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) ) | ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) ) ) (otherlv_11= ';' )? )
+ // InternalOXtype.g:79:3: () otherlv_1= 'import' ( ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) ) | ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) ) ) (otherlv_11= ';' )?
+ {
+ // InternalOXtype.g:79:3: ()
+ // InternalOXtype.g:80:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXImportDeclarationAccess().getOXImportDeclarationAction_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,13,FOLLOW_3); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXImportDeclarationAccess().getImportKeyword_1());
+
+ }
+ // InternalOXtype.g:90:3: ( ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) ) | ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) ) )
+ int alt3=4;
+ alt3 = dfa3.predict(input);
+ switch (alt3) {
+ case 1 :
+ // InternalOXtype.g:91:4: ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) )
+ {
+ // InternalOXtype.g:91:4: ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) )
+ // InternalOXtype.g:92:5: ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) )
+ {
+ // InternalOXtype.g:92:5: ( (lv_static_2_0= 'static' ) )
+ // InternalOXtype.g:93:6: (lv_static_2_0= 'static' )
+ {
+ // InternalOXtype.g:93:6: (lv_static_2_0= 'static' )
+ // InternalOXtype.g:94:7: lv_static_2_0= 'static'
+ {
+ lv_static_2_0=(Token)match(input,14,FOLLOW_4); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_static_2_0, grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXImportDeclarationRule());
+ }
+ setWithLastConsumed(current, "static", true, "static");
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:106:5: ( (lv_extension_3_0= 'extension' ) )?
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( (LA1_0==15) ) {
+ alt1=1;
+ }
+ switch (alt1) {
+ case 1 :
+ // InternalOXtype.g:107:6: (lv_extension_3_0= 'extension' )
+ {
+ // InternalOXtype.g:107:6: (lv_extension_3_0= 'extension' )
+ // InternalOXtype.g:108:7: lv_extension_3_0= 'extension'
+ {
+ lv_extension_3_0=(Token)match(input,15,FOLLOW_4); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_extension_3_0, grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXImportDeclarationRule());
+ }
+ setWithLastConsumed(current, "extension", true, "extension");
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:120:5: ( ( ruleQualifiedNameInStaticImport ) )
+ // InternalOXtype.g:121:6: ( ruleQualifiedNameInStaticImport )
+ {
+ // InternalOXtype.g:121:6: ( ruleQualifiedNameInStaticImport )
+ // InternalOXtype.g:122:7: ruleQualifiedNameInStaticImport
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXImportDeclarationRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0());
+
+ }
+ pushFollow(FOLLOW_5);
+ ruleQualifiedNameInStaticImport();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:136:5: ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) )
+ int alt2=2;
+ int LA2_0 = input.LA(1);
+
+ if ( (LA2_0==16) ) {
+ alt2=1;
+ }
+ else if ( (LA2_0==RULE_ID) ) {
+ alt2=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 2, 0, input);
+
+ throw nvae;
+ }
+ switch (alt2) {
+ case 1 :
+ // InternalOXtype.g:137:6: ( (lv_wildcard_5_0= '*' ) )
+ {
+ // InternalOXtype.g:137:6: ( (lv_wildcard_5_0= '*' ) )
+ // InternalOXtype.g:138:7: (lv_wildcard_5_0= '*' )
+ {
+ // InternalOXtype.g:138:7: (lv_wildcard_5_0= '*' )
+ // InternalOXtype.g:139:8: lv_wildcard_5_0= '*'
+ {
+ lv_wildcard_5_0=(Token)match(input,16,FOLLOW_6); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_wildcard_5_0, grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXImportDeclarationRule());
+ }
+ setWithLastConsumed(current, "wildcard", true, "*");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:152:6: ( (lv_memberName_6_0= ruleValidID ) )
+ {
+ // InternalOXtype.g:152:6: ( (lv_memberName_6_0= ruleValidID ) )
+ // InternalOXtype.g:153:7: (lv_memberName_6_0= ruleValidID )
+ {
+ // InternalOXtype.g:153:7: (lv_memberName_6_0= ruleValidID )
+ // InternalOXtype.g:154:8: lv_memberName_6_0= ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_2_0_3_1_0());
+
+ }
+ pushFollow(FOLLOW_6);
+ lv_memberName_6_0=ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXImportDeclarationRule());
+ }
+ set(
+ current,
+ "memberName",
+ lv_memberName_6_0,
+ "org.eclipse.xtext.xbase.Xtype.ValidID");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:174:4: ( ( ruleQualifiedName ) )
+ {
+ // InternalOXtype.g:174:4: ( ( ruleQualifiedName ) )
+ // InternalOXtype.g:175:5: ( ruleQualifiedName )
+ {
+ // InternalOXtype.g:175:5: ( ruleQualifiedName )
+ // InternalOXtype.g:176:6: ruleQualifiedName
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXImportDeclarationRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_1_0());
+
+ }
+ pushFollow(FOLLOW_6);
+ ruleQualifiedName();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:191:4: ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) )
+ {
+ // InternalOXtype.g:191:4: ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) )
+ // InternalOXtype.g:192:5: (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard )
+ {
+ // InternalOXtype.g:192:5: (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard )
+ // InternalOXtype.g:193:6: lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0());
+
+ }
+ pushFollow(FOLLOW_6);
+ lv_importedNamespace_8_0=ruleQualifiedNameWithWildcard();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXImportDeclarationRule());
+ }
+ set(
+ current,
+ "importedNamespace",
+ lv_importedNamespace_8_0,
+ "org.eclipse.xtext.xbase.Xtype.QualifiedNameWithWildcard");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:211:4: ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) )
+ {
+ // InternalOXtype.g:211:4: ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) )
+ // InternalOXtype.g:212:5: ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) )
+ {
+ // InternalOXtype.g:212:5: ( (lv_fqnImport_9_0= 'ns' ) )
+ // InternalOXtype.g:213:6: (lv_fqnImport_9_0= 'ns' )
+ {
+ // InternalOXtype.g:213:6: (lv_fqnImport_9_0= 'ns' )
+ // InternalOXtype.g:214:7: lv_fqnImport_9_0= 'ns'
+ {
+ lv_fqnImport_9_0=(Token)match(input,17,FOLLOW_7); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_fqnImport_9_0, grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXImportDeclarationRule());
+ }
+ setWithLastConsumed(current, "fqnImport", true, "ns");
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:226:5: ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) )
+ // InternalOXtype.g:227:6: (lv_importedFullyQualifiedName_10_0= ruleQualifiedName )
+ {
+ // InternalOXtype.g:227:6: (lv_importedFullyQualifiedName_10_0= ruleQualifiedName )
+ // InternalOXtype.g:228:7: lv_importedFullyQualifiedName_10_0= ruleQualifiedName
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0());
+
+ }
+ pushFollow(FOLLOW_6);
+ lv_importedFullyQualifiedName_10_0=ruleQualifiedName();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXImportDeclarationRule());
+ }
+ set(
+ current,
+ "importedFullyQualifiedName",
+ lv_importedFullyQualifiedName_10_0,
+ "org.eclipse.xtext.xbase.Xbase.QualifiedName");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:247:3: (otherlv_11= ';' )?
+ int alt4=2;
+ int LA4_0 = input.LA(1);
+
+ if ( (LA4_0==18) ) {
+ alt4=1;
+ }
+ switch (alt4) {
+ case 1 :
+ // InternalOXtype.g:248:4: otherlv_11= ';'
+ {
+ otherlv_11=(Token)match(input,18,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_11, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_3());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXImportDeclaration"
+
+
+ // $ANTLR start "entryRuleXAnnotation"
+ // InternalOXtype.g:257:1: entryRuleXAnnotation returns [EObject current=null] : iv_ruleXAnnotation= ruleXAnnotation EOF ;
+ public final EObject entryRuleXAnnotation() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXAnnotation = null;
+
+
+ try {
+ // InternalOXtype.g:257:52: (iv_ruleXAnnotation= ruleXAnnotation EOF )
+ // InternalOXtype.g:258:2: iv_ruleXAnnotation= ruleXAnnotation EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXAnnotationRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXAnnotation=ruleXAnnotation();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXAnnotation;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXAnnotation"
+
+
+ // $ANTLR start "ruleXAnnotation"
+ // InternalOXtype.g:264:1: ruleXAnnotation returns [EObject current=null] : ( () otherlv_1= '@' ( ( ruleQualifiedName ) ) ( ( ( '(' )=>otherlv_3= '(' ) ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )? otherlv_8= ')' )? ) ;
+ public final EObject ruleXAnnotation() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_3=null;
+ Token otherlv_5=null;
+ Token otherlv_8=null;
+ EObject lv_elementValuePairs_4_0 = null;
+
+ EObject lv_elementValuePairs_6_0 = null;
+
+ EObject lv_value_7_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:270:2: ( ( () otherlv_1= '@' ( ( ruleQualifiedName ) ) ( ( ( '(' )=>otherlv_3= '(' ) ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )? otherlv_8= ')' )? ) )
+ // InternalOXtype.g:271:2: ( () otherlv_1= '@' ( ( ruleQualifiedName ) ) ( ( ( '(' )=>otherlv_3= '(' ) ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )? otherlv_8= ')' )? )
+ {
+ // InternalOXtype.g:271:2: ( () otherlv_1= '@' ( ( ruleQualifiedName ) ) ( ( ( '(' )=>otherlv_3= '(' ) ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )? otherlv_8= ')' )? )
+ // InternalOXtype.g:272:3: () otherlv_1= '@' ( ( ruleQualifiedName ) ) ( ( ( '(' )=>otherlv_3= '(' ) ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )? otherlv_8= ')' )?
+ {
+ // InternalOXtype.g:272:3: ()
+ // InternalOXtype.g:273:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXAnnotationAccess().getXAnnotationAction_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,19,FOLLOW_7); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXAnnotationAccess().getCommercialAtKeyword_1());
+
+ }
+ // InternalOXtype.g:283:3: ( ( ruleQualifiedName ) )
+ // InternalOXtype.g:284:4: ( ruleQualifiedName )
+ {
+ // InternalOXtype.g:284:4: ( ruleQualifiedName )
+ // InternalOXtype.g:285:5: ruleQualifiedName
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXAnnotationRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeCrossReference_2_0());
+
+ }
+ pushFollow(FOLLOW_8);
+ ruleQualifiedName();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:299:3: ( ( ( '(' )=>otherlv_3= '(' ) ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )? otherlv_8= ')' )?
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( (LA7_0==20) && (synpred1_InternalOXtype())) {
+ alt7=1;
+ }
+ switch (alt7) {
+ case 1 :
+ // InternalOXtype.g:300:4: ( ( '(' )=>otherlv_3= '(' ) ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )? otherlv_8= ')'
+ {
+ // InternalOXtype.g:300:4: ( ( '(' )=>otherlv_3= '(' )
+ // InternalOXtype.g:301:5: ( '(' )=>otherlv_3= '('
+ {
+ otherlv_3=(Token)match(input,20,FOLLOW_9); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_3, grammarAccess.getXAnnotationAccess().getLeftParenthesisKeyword_3_0());
+
+ }
+
+ }
+
+ // InternalOXtype.g:307:4: ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )?
+ int alt6=3;
+ alt6 = dfa6.predict(input);
+ switch (alt6) {
+ case 1 :
+ // InternalOXtype.g:308:5: ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* )
+ {
+ // InternalOXtype.g:308:5: ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* )
+ // InternalOXtype.g:309:6: ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )*
+ {
+ // InternalOXtype.g:309:6: ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) )
+ // InternalOXtype.g:310:7: ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair )
+ {
+ // InternalOXtype.g:319:7: (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair )
+ // InternalOXtype.g:320:8: lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_0_0());
+
+ }
+ pushFollow(FOLLOW_10);
+ lv_elementValuePairs_4_0=ruleXAnnotationElementValuePair();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXAnnotationRule());
+ }
+ add(
+ current,
+ "elementValuePairs",
+ lv_elementValuePairs_4_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationElementValuePair");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:337:6: (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )*
+ loop5:
+ do {
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( (LA5_0==21) ) {
+ alt5=1;
+ }
+
+
+ switch (alt5) {
+ case 1 :
+ // InternalOXtype.g:338:7: otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) )
+ {
+ otherlv_5=(Token)match(input,21,FOLLOW_7); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_5, grammarAccess.getXAnnotationAccess().getCommaKeyword_3_1_0_1_0());
+
+ }
+ // InternalOXtype.g:342:7: ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) )
+ // InternalOXtype.g:343:8: ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair )
+ {
+ // InternalOXtype.g:352:8: (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair )
+ // InternalOXtype.g:353:9: lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_1_1_0());
+
+ }
+ pushFollow(FOLLOW_10);
+ lv_elementValuePairs_6_0=ruleXAnnotationElementValuePair();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXAnnotationRule());
+ }
+ add(
+ current,
+ "elementValuePairs",
+ lv_elementValuePairs_6_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationElementValuePair");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop5;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:373:5: ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) )
+ {
+ // InternalOXtype.g:373:5: ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) )
+ // InternalOXtype.g:374:6: (lv_value_7_0= ruleXAnnotationElementValueOrCommaList )
+ {
+ // InternalOXtype.g:374:6: (lv_value_7_0= ruleXAnnotationElementValueOrCommaList )
+ // InternalOXtype.g:375:7: lv_value_7_0= ruleXAnnotationElementValueOrCommaList
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAnnotationAccess().getValueXAnnotationElementValueOrCommaListParserRuleCall_3_1_1_0());
+
+ }
+ pushFollow(FOLLOW_11);
+ lv_value_7_0=ruleXAnnotationElementValueOrCommaList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXAnnotationRule());
+ }
+ set(
+ current,
+ "value",
+ lv_value_7_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationElementValueOrCommaList");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ otherlv_8=(Token)match(input,22,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_8, grammarAccess.getXAnnotationAccess().getRightParenthesisKeyword_3_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXAnnotation"
+
+
+ // $ANTLR start "entryRuleXAnnotationElementValuePair"
+ // InternalOXtype.g:402:1: entryRuleXAnnotationElementValuePair returns [EObject current=null] : iv_ruleXAnnotationElementValuePair= ruleXAnnotationElementValuePair EOF ;
+ public final EObject entryRuleXAnnotationElementValuePair() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXAnnotationElementValuePair = null;
+
+
+ try {
+ // InternalOXtype.g:402:68: (iv_ruleXAnnotationElementValuePair= ruleXAnnotationElementValuePair EOF )
+ // InternalOXtype.g:403:2: iv_ruleXAnnotationElementValuePair= ruleXAnnotationElementValuePair EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXAnnotationElementValuePairRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXAnnotationElementValuePair=ruleXAnnotationElementValuePair();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXAnnotationElementValuePair;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXAnnotationElementValuePair"
+
+
+ // $ANTLR start "ruleXAnnotationElementValuePair"
+ // InternalOXtype.g:409:1: ruleXAnnotationElementValuePair returns [EObject current=null] : ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> ( ( ( ruleValidID ) ) otherlv_1= '=' ) ) ( (lv_value_2_0= ruleXAnnotationElementValue ) ) ) ;
+ public final EObject ruleXAnnotationElementValuePair() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ EObject lv_value_2_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:415:2: ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> ( ( ( ruleValidID ) ) otherlv_1= '=' ) ) ( (lv_value_2_0= ruleXAnnotationElementValue ) ) ) )
+ // InternalOXtype.g:416:2: ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> ( ( ( ruleValidID ) ) otherlv_1= '=' ) ) ( (lv_value_2_0= ruleXAnnotationElementValue ) ) )
+ {
+ // InternalOXtype.g:416:2: ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> ( ( ( ruleValidID ) ) otherlv_1= '=' ) ) ( (lv_value_2_0= ruleXAnnotationElementValue ) ) )
+ // InternalOXtype.g:417:3: ( ( ( ( ( ruleValidID ) ) '=' ) )=> ( ( ( ruleValidID ) ) otherlv_1= '=' ) ) ( (lv_value_2_0= ruleXAnnotationElementValue ) )
+ {
+ // InternalOXtype.g:417:3: ( ( ( ( ( ruleValidID ) ) '=' ) )=> ( ( ( ruleValidID ) ) otherlv_1= '=' ) )
+ // InternalOXtype.g:418:4: ( ( ( ( ruleValidID ) ) '=' ) )=> ( ( ( ruleValidID ) ) otherlv_1= '=' )
+ {
+ // InternalOXtype.g:427:4: ( ( ( ruleValidID ) ) otherlv_1= '=' )
+ // InternalOXtype.g:428:5: ( ( ruleValidID ) ) otherlv_1= '='
+ {
+ // InternalOXtype.g:428:5: ( ( ruleValidID ) )
+ // InternalOXtype.g:429:6: ( ruleValidID )
+ {
+ // InternalOXtype.g:429:6: ( ruleValidID )
+ // InternalOXtype.g:430:7: ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXAnnotationElementValuePairRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationCrossReference_0_0_0_0());
+
+ }
+ pushFollow(FOLLOW_12);
+ ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ otherlv_1=(Token)match(input,23,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXAnnotationElementValuePairAccess().getEqualsSignKeyword_0_0_1());
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:450:3: ( (lv_value_2_0= ruleXAnnotationElementValue ) )
+ // InternalOXtype.g:451:4: (lv_value_2_0= ruleXAnnotationElementValue )
+ {
+ // InternalOXtype.g:451:4: (lv_value_2_0= ruleXAnnotationElementValue )
+ // InternalOXtype.g:452:5: lv_value_2_0= ruleXAnnotationElementValue
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAnnotationElementValuePairAccess().getValueXAnnotationElementValueParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_value_2_0=ruleXAnnotationElementValue();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXAnnotationElementValuePairRule());
+ }
+ set(
+ current,
+ "value",
+ lv_value_2_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationElementValue");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXAnnotationElementValuePair"
+
+
+ // $ANTLR start "entryRuleXAnnotationElementValueOrCommaList"
+ // InternalOXtype.g:473:1: entryRuleXAnnotationElementValueOrCommaList returns [EObject current=null] : iv_ruleXAnnotationElementValueOrCommaList= ruleXAnnotationElementValueOrCommaList EOF ;
+ public final EObject entryRuleXAnnotationElementValueOrCommaList() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXAnnotationElementValueOrCommaList = null;
+
+
+ try {
+ // InternalOXtype.g:473:75: (iv_ruleXAnnotationElementValueOrCommaList= ruleXAnnotationElementValueOrCommaList EOF )
+ // InternalOXtype.g:474:2: iv_ruleXAnnotationElementValueOrCommaList= ruleXAnnotationElementValueOrCommaList EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXAnnotationElementValueOrCommaList=ruleXAnnotationElementValueOrCommaList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXAnnotationElementValueOrCommaList;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXAnnotationElementValueOrCommaList"
+
+
+ // $ANTLR start "ruleXAnnotationElementValueOrCommaList"
+ // InternalOXtype.g:480:1: ruleXAnnotationElementValueOrCommaList returns [EObject current=null] : ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | (this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )? ) ) ;
+ public final EObject ruleXAnnotationElementValueOrCommaList() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_2=null;
+ Token otherlv_4=null;
+ Token otherlv_6=null;
+ Token otherlv_9=null;
+ EObject lv_elements_3_0 = null;
+
+ EObject lv_elements_5_0 = null;
+
+ EObject this_XAnnotationOrExpression_7 = null;
+
+ EObject lv_elements_10_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:486:2: ( ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | (this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )? ) ) )
+ // InternalOXtype.g:487:2: ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | (this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )? ) )
+ {
+ // InternalOXtype.g:487:2: ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | (this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )? ) )
+ int alt12=2;
+ alt12 = dfa12.predict(input);
+ switch (alt12) {
+ case 1 :
+ // InternalOXtype.g:488:3: ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' )
+ {
+ // InternalOXtype.g:488:3: ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' )
+ // InternalOXtype.g:489:4: ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']'
+ {
+ // InternalOXtype.g:489:4: ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) )
+ // InternalOXtype.g:490:5: ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' )
+ {
+ // InternalOXtype.g:497:5: ( () otherlv_1= '#' otherlv_2= '[' )
+ // InternalOXtype.g:498:6: () otherlv_1= '#' otherlv_2= '['
+ {
+ // InternalOXtype.g:498:6: ()
+ // InternalOXtype.g:499:7:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralAction_0_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,24,FOLLOW_14); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getNumberSignKeyword_0_0_0_1());
+
+ }
+ otherlv_2=(Token)match(input,25,FOLLOW_15); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getLeftSquareBracketKeyword_0_0_0_2());
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:515:4: ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )?
+ int alt9=2;
+ int LA9_0 = input.LA(1);
+
+ if ( ((LA9_0>=RULE_STRING && LA9_0<=RULE_ID)||(LA9_0>=13 && LA9_0<=15)||(LA9_0>=19 && LA9_0<=20)||(LA9_0>=24 && LA9_0<=25)||LA9_0==32||(LA9_0>=48 && LA9_0<=49)||LA9_0==53||LA9_0==60||LA9_0==63||LA9_0==65||(LA9_0>=69 && LA9_0<=71)||(LA9_0>=74 && LA9_0<=83)||LA9_0==85) ) {
+ alt9=1;
+ }
+ switch (alt9) {
+ case 1 :
+ // InternalOXtype.g:516:5: ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )*
+ {
+ // InternalOXtype.g:516:5: ( (lv_elements_3_0= ruleXAnnotationOrExpression ) )
+ // InternalOXtype.g:517:6: (lv_elements_3_0= ruleXAnnotationOrExpression )
+ {
+ // InternalOXtype.g:517:6: (lv_elements_3_0= ruleXAnnotationOrExpression )
+ // InternalOXtype.g:518:7: lv_elements_3_0= ruleXAnnotationOrExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0());
+
+ }
+ pushFollow(FOLLOW_16);
+ lv_elements_3_0=ruleXAnnotationOrExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+ }
+ add(
+ current,
+ "elements",
+ lv_elements_3_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:535:5: (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )*
+ loop8:
+ do {
+ int alt8=2;
+ int LA8_0 = input.LA(1);
+
+ if ( (LA8_0==21) ) {
+ alt8=1;
+ }
+
+
+ switch (alt8) {
+ case 1 :
+ // InternalOXtype.g:536:6: otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) )
+ {
+ otherlv_4=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_4, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_0_1_1_0());
+
+ }
+ // InternalOXtype.g:540:6: ( (lv_elements_5_0= ruleXAnnotationOrExpression ) )
+ // InternalOXtype.g:541:7: (lv_elements_5_0= ruleXAnnotationOrExpression )
+ {
+ // InternalOXtype.g:541:7: (lv_elements_5_0= ruleXAnnotationOrExpression )
+ // InternalOXtype.g:542:8: lv_elements_5_0= ruleXAnnotationOrExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_16);
+ lv_elements_5_0=ruleXAnnotationOrExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+ }
+ add(
+ current,
+ "elements",
+ lv_elements_5_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop8;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ otherlv_6=(Token)match(input,26,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_6, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getRightSquareBracketKeyword_0_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:567:3: (this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )? )
+ {
+ // InternalOXtype.g:567:3: (this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )? )
+ // InternalOXtype.g:568:4: this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )?
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXAnnotationOrExpressionParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_17);
+ this_XAnnotationOrExpression_7=ruleXAnnotationOrExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XAnnotationOrExpression_7;
+ afterParserOrEnumRuleCall();
+
+ }
+ // InternalOXtype.g:576:4: ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )?
+ int alt11=2;
+ int LA11_0 = input.LA(1);
+
+ if ( (LA11_0==21) ) {
+ alt11=1;
+ }
+ switch (alt11) {
+ case 1 :
+ // InternalOXtype.g:577:5: () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+
+ {
+ // InternalOXtype.g:577:5: ()
+ // InternalOXtype.g:578:6:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndAdd(
+ grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:584:5: (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+
+ int cnt10=0;
+ loop10:
+ do {
+ int alt10=2;
+ int LA10_0 = input.LA(1);
+
+ if ( (LA10_0==21) ) {
+ alt10=1;
+ }
+
+
+ switch (alt10) {
+ case 1 :
+ // InternalOXtype.g:585:6: otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) )
+ {
+ otherlv_9=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_9, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_1_1_1_0());
+
+ }
+ // InternalOXtype.g:589:6: ( (lv_elements_10_0= ruleXAnnotationOrExpression ) )
+ // InternalOXtype.g:590:7: (lv_elements_10_0= ruleXAnnotationOrExpression )
+ {
+ // InternalOXtype.g:590:7: (lv_elements_10_0= ruleXAnnotationOrExpression )
+ // InternalOXtype.g:591:8: lv_elements_10_0= ruleXAnnotationOrExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_1_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_17);
+ lv_elements_10_0=ruleXAnnotationOrExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+ }
+ add(
+ current,
+ "elements",
+ lv_elements_10_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ if ( cnt10 >= 1 ) break loop10;
+ if (state.backtracking>0) {state.failed=true; return current;}
+ EarlyExitException eee =
+ new EarlyExitException(10, input);
+ throw eee;
+ }
+ cnt10++;
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXAnnotationElementValueOrCommaList"
+
+
+ // $ANTLR start "entryRuleXAnnotationElementValue"
+ // InternalOXtype.g:615:1: entryRuleXAnnotationElementValue returns [EObject current=null] : iv_ruleXAnnotationElementValue= ruleXAnnotationElementValue EOF ;
+ public final EObject entryRuleXAnnotationElementValue() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXAnnotationElementValue = null;
+
+
+ try {
+ // InternalOXtype.g:615:64: (iv_ruleXAnnotationElementValue= ruleXAnnotationElementValue EOF )
+ // InternalOXtype.g:616:2: iv_ruleXAnnotationElementValue= ruleXAnnotationElementValue EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXAnnotationElementValueRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXAnnotationElementValue=ruleXAnnotationElementValue();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXAnnotationElementValue;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXAnnotationElementValue"
+
+
+ // $ANTLR start "ruleXAnnotationElementValue"
+ // InternalOXtype.g:622:1: ruleXAnnotationElementValue returns [EObject current=null] : ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ) ;
+ public final EObject ruleXAnnotationElementValue() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_2=null;
+ Token otherlv_4=null;
+ Token otherlv_6=null;
+ EObject lv_elements_3_0 = null;
+
+ EObject lv_elements_5_0 = null;
+
+ EObject this_XAnnotationOrExpression_7 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:628:2: ( ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ) )
+ // InternalOXtype.g:629:2: ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression )
+ {
+ // InternalOXtype.g:629:2: ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression )
+ int alt15=2;
+ alt15 = dfa15.predict(input);
+ switch (alt15) {
+ case 1 :
+ // InternalOXtype.g:630:3: ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' )
+ {
+ // InternalOXtype.g:630:3: ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' )
+ // InternalOXtype.g:631:4: ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']'
+ {
+ // InternalOXtype.g:631:4: ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) )
+ // InternalOXtype.g:632:5: ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' )
+ {
+ // InternalOXtype.g:639:5: ( () otherlv_1= '#' otherlv_2= '[' )
+ // InternalOXtype.g:640:6: () otherlv_1= '#' otherlv_2= '['
+ {
+ // InternalOXtype.g:640:6: ()
+ // InternalOXtype.g:641:7:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXAnnotationElementValueAccess().getXListLiteralAction_0_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,24,FOLLOW_14); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXAnnotationElementValueAccess().getNumberSignKeyword_0_0_0_1());
+
+ }
+ otherlv_2=(Token)match(input,25,FOLLOW_15); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXAnnotationElementValueAccess().getLeftSquareBracketKeyword_0_0_0_2());
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:657:4: ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )?
+ int alt14=2;
+ int LA14_0 = input.LA(1);
+
+ if ( ((LA14_0>=RULE_STRING && LA14_0<=RULE_ID)||(LA14_0>=13 && LA14_0<=15)||(LA14_0>=19 && LA14_0<=20)||(LA14_0>=24 && LA14_0<=25)||LA14_0==32||(LA14_0>=48 && LA14_0<=49)||LA14_0==53||LA14_0==60||LA14_0==63||LA14_0==65||(LA14_0>=69 && LA14_0<=71)||(LA14_0>=74 && LA14_0<=83)||LA14_0==85) ) {
+ alt14=1;
+ }
+ switch (alt14) {
+ case 1 :
+ // InternalOXtype.g:658:5: ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )*
+ {
+ // InternalOXtype.g:658:5: ( (lv_elements_3_0= ruleXAnnotationOrExpression ) )
+ // InternalOXtype.g:659:6: (lv_elements_3_0= ruleXAnnotationOrExpression )
+ {
+ // InternalOXtype.g:659:6: (lv_elements_3_0= ruleXAnnotationOrExpression )
+ // InternalOXtype.g:660:7: lv_elements_3_0= ruleXAnnotationOrExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0());
+
+ }
+ pushFollow(FOLLOW_16);
+ lv_elements_3_0=ruleXAnnotationOrExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXAnnotationElementValueRule());
+ }
+ add(
+ current,
+ "elements",
+ lv_elements_3_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:677:5: (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )*
+ loop13:
+ do {
+ int alt13=2;
+ int LA13_0 = input.LA(1);
+
+ if ( (LA13_0==21) ) {
+ alt13=1;
+ }
+
+
+ switch (alt13) {
+ case 1 :
+ // InternalOXtype.g:678:6: otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) )
+ {
+ otherlv_4=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_4, grammarAccess.getXAnnotationElementValueAccess().getCommaKeyword_0_1_1_0());
+
+ }
+ // InternalOXtype.g:682:6: ( (lv_elements_5_0= ruleXAnnotationOrExpression ) )
+ // InternalOXtype.g:683:7: (lv_elements_5_0= ruleXAnnotationOrExpression )
+ {
+ // InternalOXtype.g:683:7: (lv_elements_5_0= ruleXAnnotationOrExpression )
+ // InternalOXtype.g:684:8: lv_elements_5_0= ruleXAnnotationOrExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_16);
+ lv_elements_5_0=ruleXAnnotationOrExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXAnnotationElementValueRule());
+ }
+ add(
+ current,
+ "elements",
+ lv_elements_5_0,
+ "org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop13;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ otherlv_6=(Token)match(input,26,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_6, grammarAccess.getXAnnotationElementValueAccess().getRightSquareBracketKeyword_0_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:709:3: this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XAnnotationOrExpression_7=ruleXAnnotationOrExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XAnnotationOrExpression_7;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXAnnotationElementValue"
+
+
+ // $ANTLR start "entryRuleXAnnotationOrExpression"
+ // InternalOXtype.g:721:1: entryRuleXAnnotationOrExpression returns [EObject current=null] : iv_ruleXAnnotationOrExpression= ruleXAnnotationOrExpression EOF ;
+ public final EObject entryRuleXAnnotationOrExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXAnnotationOrExpression = null;
+
+
+ try {
+ // InternalOXtype.g:721:64: (iv_ruleXAnnotationOrExpression= ruleXAnnotationOrExpression EOF )
+ // InternalOXtype.g:722:2: iv_ruleXAnnotationOrExpression= ruleXAnnotationOrExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXAnnotationOrExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXAnnotationOrExpression=ruleXAnnotationOrExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXAnnotationOrExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXAnnotationOrExpression"
+
+
+ // $ANTLR start "ruleXAnnotationOrExpression"
+ // InternalOXtype.g:728:1: ruleXAnnotationOrExpression returns [EObject current=null] : (this_XAnnotation_0= ruleXAnnotation | this_XExpression_1= ruleXExpression ) ;
+ public final EObject ruleXAnnotationOrExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_XAnnotation_0 = null;
+
+ EObject this_XExpression_1 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:734:2: ( (this_XAnnotation_0= ruleXAnnotation | this_XExpression_1= ruleXExpression ) )
+ // InternalOXtype.g:735:2: (this_XAnnotation_0= ruleXAnnotation | this_XExpression_1= ruleXExpression )
+ {
+ // InternalOXtype.g:735:2: (this_XAnnotation_0= ruleXAnnotation | this_XExpression_1= ruleXExpression )
+ int alt16=2;
+ int LA16_0 = input.LA(1);
+
+ if ( (LA16_0==19) ) {
+ alt16=1;
+ }
+ else if ( ((LA16_0>=RULE_STRING && LA16_0<=RULE_ID)||(LA16_0>=13 && LA16_0<=15)||LA16_0==20||(LA16_0>=24 && LA16_0<=25)||LA16_0==32||(LA16_0>=48 && LA16_0<=49)||LA16_0==53||LA16_0==60||LA16_0==63||LA16_0==65||(LA16_0>=69 && LA16_0<=71)||(LA16_0>=74 && LA16_0<=83)||LA16_0==85) ) {
+ alt16=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 16, 0, input);
+
+ throw nvae;
+ }
+ switch (alt16) {
+ case 1 :
+ // InternalOXtype.g:736:3: this_XAnnotation_0= ruleXAnnotation
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XAnnotation_0=ruleXAnnotation();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XAnnotation_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:745:3: this_XExpression_1= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XExpression_1=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XExpression_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXAnnotationOrExpression"
+
+
+ // $ANTLR start "entryRuleXExpression"
+ // InternalOXtype.g:757:1: entryRuleXExpression returns [EObject current=null] : iv_ruleXExpression= ruleXExpression EOF ;
+ public final EObject entryRuleXExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXExpression = null;
+
+
+ try {
+ // InternalOXtype.g:757:52: (iv_ruleXExpression= ruleXExpression EOF )
+ // InternalOXtype.g:758:2: iv_ruleXExpression= ruleXExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXExpression=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXExpression"
+
+
+ // $ANTLR start "ruleXExpression"
+ // InternalOXtype.g:764:1: ruleXExpression returns [EObject current=null] : this_XAssignment_0= ruleXAssignment ;
+ public final EObject ruleXExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_XAssignment_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:770:2: (this_XAssignment_0= ruleXAssignment )
+ // InternalOXtype.g:771:2: this_XAssignment_0= ruleXAssignment
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XAssignment_0=ruleXAssignment();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XAssignment_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXExpression"
+
+
+ // $ANTLR start "entryRuleXAssignment"
+ // InternalOXtype.g:782:1: entryRuleXAssignment returns [EObject current=null] : iv_ruleXAssignment= ruleXAssignment EOF ;
+ public final EObject entryRuleXAssignment() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXAssignment = null;
+
+
+ try {
+ // InternalOXtype.g:782:52: (iv_ruleXAssignment= ruleXAssignment EOF )
+ // InternalOXtype.g:783:2: iv_ruleXAssignment= ruleXAssignment EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXAssignmentRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXAssignment=ruleXAssignment();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXAssignment;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXAssignment"
+
+
+ // $ANTLR start "ruleXAssignment"
+ // InternalOXtype.g:789:1: ruleXAssignment returns [EObject current=null] : ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) ) ;
+ public final EObject ruleXAssignment() throws RecognitionException {
+ EObject current = null;
+
+ EObject lv_value_3_0 = null;
+
+ EObject this_XOrExpression_4 = null;
+
+ EObject lv_rightOperand_7_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:795:2: ( ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) ) )
+ // InternalOXtype.g:796:2: ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) )
+ {
+ // InternalOXtype.g:796:2: ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) )
+ int alt18=2;
+ switch ( input.LA(1) ) {
+ case RULE_ID:
+ {
+ int LA18_1 = input.LA(2);
+
+ if ( (LA18_1==EOF||(LA18_1>=RULE_STRING && LA18_1<=RULE_ID)||(LA18_1>=13 && LA18_1<=16)||LA18_1==18||(LA18_1>=20 && LA18_1<=22)||(LA18_1>=24 && LA18_1<=61)||(LA18_1>=63 && LA18_1<=86)) ) {
+ alt18=2;
+ }
+ else if ( (LA18_1==23) ) {
+ alt18=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 18, 1, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case 74:
+ {
+ int LA18_2 = input.LA(2);
+
+ if ( (LA18_2==EOF||(LA18_2>=RULE_STRING && LA18_2<=RULE_ID)||(LA18_2>=13 && LA18_2<=16)||LA18_2==18||(LA18_2>=20 && LA18_2<=22)||(LA18_2>=24 && LA18_2<=61)||(LA18_2>=63 && LA18_2<=86)) ) {
+ alt18=2;
+ }
+ else if ( (LA18_2==23) ) {
+ alt18=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 18, 2, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case 14:
+ {
+ int LA18_3 = input.LA(2);
+
+ if ( (LA18_3==23) ) {
+ alt18=1;
+ }
+ else if ( (LA18_3==EOF||(LA18_3>=RULE_STRING && LA18_3<=RULE_ID)||(LA18_3>=13 && LA18_3<=16)||LA18_3==18||(LA18_3>=20 && LA18_3<=22)||(LA18_3>=24 && LA18_3<=61)||(LA18_3>=63 && LA18_3<=86)) ) {
+ alt18=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 18, 3, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case 13:
+ {
+ int LA18_4 = input.LA(2);
+
+ if ( (LA18_4==23) ) {
+ alt18=1;
+ }
+ else if ( (LA18_4==EOF||(LA18_4>=RULE_STRING && LA18_4<=RULE_ID)||(LA18_4>=13 && LA18_4<=16)||LA18_4==18||(LA18_4>=20 && LA18_4<=22)||(LA18_4>=24 && LA18_4<=61)||(LA18_4>=63 && LA18_4<=86)) ) {
+ alt18=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 18, 4, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case 15:
+ {
+ int LA18_5 = input.LA(2);
+
+ if ( (LA18_5==EOF||(LA18_5>=RULE_STRING && LA18_5<=RULE_ID)||(LA18_5>=13 && LA18_5<=16)||LA18_5==18||(LA18_5>=20 && LA18_5<=22)||(LA18_5>=24 && LA18_5<=61)||(LA18_5>=63 && LA18_5<=86)) ) {
+ alt18=2;
+ }
+ else if ( (LA18_5==23) ) {
+ alt18=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 18, 5, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case RULE_STRING:
+ case RULE_HEX:
+ case RULE_INT:
+ case RULE_DECIMAL:
+ case 20:
+ case 24:
+ case 25:
+ case 32:
+ case 48:
+ case 49:
+ case 53:
+ case 60:
+ case 63:
+ case 65:
+ case 69:
+ case 70:
+ case 71:
+ case 75:
+ case 76:
+ case 77:
+ case 78:
+ case 79:
+ case 80:
+ case 81:
+ case 82:
+ case 83:
+ case 85:
+ {
+ alt18=2;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 18, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt18) {
+ case 1 :
+ // InternalOXtype.g:797:3: ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) )
+ {
+ // InternalOXtype.g:797:3: ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) )
+ // InternalOXtype.g:798:4: () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) )
+ {
+ // InternalOXtype.g:798:4: ()
+ // InternalOXtype.g:799:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:805:4: ( ( ruleFeatureCallID ) )
+ // InternalOXtype.g:806:5: ( ruleFeatureCallID )
+ {
+ // InternalOXtype.g:806:5: ( ruleFeatureCallID )
+ // InternalOXtype.g:807:6: ruleFeatureCallID
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXAssignmentRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0());
+
+ }
+ pushFollow(FOLLOW_12);
+ ruleFeatureCallID();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2());
+
+ }
+ pushFollow(FOLLOW_13);
+ ruleOpSingleAssign();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+ // InternalOXtype.g:828:4: ( (lv_value_3_0= ruleXAssignment ) )
+ // InternalOXtype.g:829:5: (lv_value_3_0= ruleXAssignment )
+ {
+ // InternalOXtype.g:829:5: (lv_value_3_0= ruleXAssignment )
+ // InternalOXtype.g:830:6: lv_value_3_0= ruleXAssignment
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_value_3_0=ruleXAssignment();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXAssignmentRule());
+ }
+ set(
+ current,
+ "value",
+ lv_value_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XAssignment");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:849:3: (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? )
+ {
+ // InternalOXtype.g:849:3: (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? )
+ // InternalOXtype.g:850:4: this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )?
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_18);
+ this_XOrExpression_4=ruleXOrExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XOrExpression_4;
+ afterParserOrEnumRuleCall();
+
+ }
+ // InternalOXtype.g:858:4: ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )?
+ int alt17=2;
+ alt17 = dfa17.predict(input);
+ switch (alt17) {
+ case 1 :
+ // InternalOXtype.g:859:5: ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) )
+ {
+ // InternalOXtype.g:859:5: ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) )
+ // InternalOXtype.g:860:6: ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) )
+ {
+ // InternalOXtype.g:870:6: ( () ( ( ruleOpMultiAssign ) ) )
+ // InternalOXtype.g:871:7: () ( ( ruleOpMultiAssign ) )
+ {
+ // InternalOXtype.g:871:7: ()
+ // InternalOXtype.g:872:8:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:878:7: ( ( ruleOpMultiAssign ) )
+ // InternalOXtype.g:879:8: ( ruleOpMultiAssign )
+ {
+ // InternalOXtype.g:879:8: ( ruleOpMultiAssign )
+ // InternalOXtype.g:880:9: ruleOpMultiAssign
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXAssignmentRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0());
+
+ }
+ pushFollow(FOLLOW_13);
+ ruleOpMultiAssign();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:896:5: ( (lv_rightOperand_7_0= ruleXAssignment ) )
+ // InternalOXtype.g:897:6: (lv_rightOperand_7_0= ruleXAssignment )
+ {
+ // InternalOXtype.g:897:6: (lv_rightOperand_7_0= ruleXAssignment )
+ // InternalOXtype.g:898:7: lv_rightOperand_7_0= ruleXAssignment
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_rightOperand_7_0=ruleXAssignment();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXAssignmentRule());
+ }
+ set(
+ current,
+ "rightOperand",
+ lv_rightOperand_7_0,
+ "org.eclipse.xtext.xbase.Xbase.XAssignment");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXAssignment"
+
+
+ // $ANTLR start "entryRuleOpSingleAssign"
+ // InternalOXtype.g:921:1: entryRuleOpSingleAssign returns [String current=null] : iv_ruleOpSingleAssign= ruleOpSingleAssign EOF ;
+ public final String entryRuleOpSingleAssign() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleOpSingleAssign = null;
+
+
+ try {
+ // InternalOXtype.g:921:54: (iv_ruleOpSingleAssign= ruleOpSingleAssign EOF )
+ // InternalOXtype.g:922:2: iv_ruleOpSingleAssign= ruleOpSingleAssign EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getOpSingleAssignRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleOpSingleAssign=ruleOpSingleAssign();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleOpSingleAssign.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleOpSingleAssign"
+
+
+ // $ANTLR start "ruleOpSingleAssign"
+ // InternalOXtype.g:928:1: ruleOpSingleAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= '=' ;
+ public final AntlrDatatypeRuleToken ruleOpSingleAssign() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token kw=null;
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:934:2: (kw= '=' )
+ // InternalOXtype.g:935:2: kw= '='
+ {
+ kw=(Token)match(input,23,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword());
+
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleOpSingleAssign"
+
+
+ // $ANTLR start "entryRuleOpMultiAssign"
+ // InternalOXtype.g:943:1: entryRuleOpMultiAssign returns [String current=null] : iv_ruleOpMultiAssign= ruleOpMultiAssign EOF ;
+ public final String entryRuleOpMultiAssign() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleOpMultiAssign = null;
+
+
+ try {
+ // InternalOXtype.g:943:53: (iv_ruleOpMultiAssign= ruleOpMultiAssign EOF )
+ // InternalOXtype.g:944:2: iv_ruleOpMultiAssign= ruleOpMultiAssign EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getOpMultiAssignRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleOpMultiAssign=ruleOpMultiAssign();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleOpMultiAssign.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleOpMultiAssign"
+
+
+ // $ANTLR start "ruleOpMultiAssign"
+ // InternalOXtype.g:950:1: ruleOpMultiAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) ) ;
+ public final AntlrDatatypeRuleToken ruleOpMultiAssign() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token kw=null;
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:956:2: ( (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) ) )
+ // InternalOXtype.g:957:2: (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) )
+ {
+ // InternalOXtype.g:957:2: (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) )
+ int alt20=7;
+ switch ( input.LA(1) ) {
+ case 27:
+ {
+ alt20=1;
+ }
+ break;
+ case 28:
+ {
+ alt20=2;
+ }
+ break;
+ case 29:
+ {
+ alt20=3;
+ }
+ break;
+ case 30:
+ {
+ alt20=4;
+ }
+ break;
+ case 31:
+ {
+ alt20=5;
+ }
+ break;
+ case 32:
+ {
+ alt20=6;
+ }
+ break;
+ case 33:
+ {
+ alt20=7;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 20, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt20) {
+ case 1 :
+ // InternalOXtype.g:958:3: kw= '+='
+ {
+ kw=(Token)match(input,27,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:964:3: kw= '-='
+ {
+ kw=(Token)match(input,28,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1());
+
+ }
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:970:3: kw= '*='
+ {
+ kw=(Token)match(input,29,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2());
+
+ }
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:976:3: kw= '/='
+ {
+ kw=(Token)match(input,30,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3());
+
+ }
+
+ }
+ break;
+ case 5 :
+ // InternalOXtype.g:982:3: kw= '%='
+ {
+ kw=(Token)match(input,31,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4());
+
+ }
+
+ }
+ break;
+ case 6 :
+ // InternalOXtype.g:988:3: (kw= '<' kw= '<' kw= '=' )
+ {
+ // InternalOXtype.g:988:3: (kw= '<' kw= '<' kw= '=' )
+ // InternalOXtype.g:989:4: kw= '<' kw= '<' kw= '='
+ {
+ kw=(Token)match(input,32,FOLLOW_19); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0());
+
+ }
+ kw=(Token)match(input,32,FOLLOW_12); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1());
+
+ }
+ kw=(Token)match(input,23,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 7 :
+ // InternalOXtype.g:1006:3: (kw= '>' (kw= '>' )? kw= '>=' )
+ {
+ // InternalOXtype.g:1006:3: (kw= '>' (kw= '>' )? kw= '>=' )
+ // InternalOXtype.g:1007:4: kw= '>' (kw= '>' )? kw= '>='
+ {
+ kw=(Token)match(input,33,FOLLOW_20); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0());
+
+ }
+ // InternalOXtype.g:1012:4: (kw= '>' )?
+ int alt19=2;
+ int LA19_0 = input.LA(1);
+
+ if ( (LA19_0==33) ) {
+ alt19=1;
+ }
+ switch (alt19) {
+ case 1 :
+ // InternalOXtype.g:1013:5: kw= '>'
+ {
+ kw=(Token)match(input,33,FOLLOW_21); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+ kw=(Token)match(input,34,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleOpMultiAssign"
+
+
+ // $ANTLR start "entryRuleXOrExpression"
+ // InternalOXtype.g:1029:1: entryRuleXOrExpression returns [EObject current=null] : iv_ruleXOrExpression= ruleXOrExpression EOF ;
+ public final EObject entryRuleXOrExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXOrExpression = null;
+
+
+ try {
+ // InternalOXtype.g:1029:54: (iv_ruleXOrExpression= ruleXOrExpression EOF )
+ // InternalOXtype.g:1030:2: iv_ruleXOrExpression= ruleXOrExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXOrExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXOrExpression=ruleXOrExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXOrExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXOrExpression"
+
+
+ // $ANTLR start "ruleXOrExpression"
+ // InternalOXtype.g:1036:1: ruleXOrExpression returns [EObject current=null] : (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* ) ;
+ public final EObject ruleXOrExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_XAndExpression_0 = null;
+
+ EObject lv_rightOperand_3_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:1042:2: ( (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* ) )
+ // InternalOXtype.g:1043:2: (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* )
+ {
+ // InternalOXtype.g:1043:2: (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* )
+ // InternalOXtype.g:1044:3: this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_22);
+ this_XAndExpression_0=ruleXAndExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XAndExpression_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // InternalOXtype.g:1052:3: ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )*
+ loop21:
+ do {
+ int alt21=2;
+ int LA21_0 = input.LA(1);
+
+ if ( (LA21_0==35) ) {
+ int LA21_2 = input.LA(2);
+
+ if ( (synpred8_InternalOXtype()) ) {
+ alt21=1;
+ }
+
+
+ }
+
+
+ switch (alt21) {
+ case 1 :
+ // InternalOXtype.g:1053:4: ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) )
+ {
+ // InternalOXtype.g:1053:4: ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) )
+ // InternalOXtype.g:1054:5: ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) )
+ {
+ // InternalOXtype.g:1064:5: ( () ( ( ruleOpOr ) ) )
+ // InternalOXtype.g:1065:6: () ( ( ruleOpOr ) )
+ {
+ // InternalOXtype.g:1065:6: ()
+ // InternalOXtype.g:1066:7:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:1072:6: ( ( ruleOpOr ) )
+ // InternalOXtype.g:1073:7: ( ruleOpOr )
+ {
+ // InternalOXtype.g:1073:7: ( ruleOpOr )
+ // InternalOXtype.g:1074:8: ruleOpOr
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXOrExpressionRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+
+ }
+ pushFollow(FOLLOW_13);
+ ruleOpOr();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:1090:4: ( (lv_rightOperand_3_0= ruleXAndExpression ) )
+ // InternalOXtype.g:1091:5: (lv_rightOperand_3_0= ruleXAndExpression )
+ {
+ // InternalOXtype.g:1091:5: (lv_rightOperand_3_0= ruleXAndExpression )
+ // InternalOXtype.g:1092:6: lv_rightOperand_3_0= ruleXAndExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_22);
+ lv_rightOperand_3_0=ruleXAndExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXOrExpressionRule());
+ }
+ set(
+ current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XAndExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop21;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXOrExpression"
+
+
+ // $ANTLR start "entryRuleOpOr"
+ // InternalOXtype.g:1114:1: entryRuleOpOr returns [String current=null] : iv_ruleOpOr= ruleOpOr EOF ;
+ public final String entryRuleOpOr() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleOpOr = null;
+
+
+ try {
+ // InternalOXtype.g:1114:44: (iv_ruleOpOr= ruleOpOr EOF )
+ // InternalOXtype.g:1115:2: iv_ruleOpOr= ruleOpOr EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getOpOrRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleOpOr=ruleOpOr();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleOpOr.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleOpOr"
+
+
+ // $ANTLR start "ruleOpOr"
+ // InternalOXtype.g:1121:1: ruleOpOr returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= '||' ;
+ public final AntlrDatatypeRuleToken ruleOpOr() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token kw=null;
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:1127:2: (kw= '||' )
+ // InternalOXtype.g:1128:2: kw= '||'
+ {
+ kw=(Token)match(input,35,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword());
+
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleOpOr"
+
+
+ // $ANTLR start "entryRuleXAndExpression"
+ // InternalOXtype.g:1136:1: entryRuleXAndExpression returns [EObject current=null] : iv_ruleXAndExpression= ruleXAndExpression EOF ;
+ public final EObject entryRuleXAndExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXAndExpression = null;
+
+
+ try {
+ // InternalOXtype.g:1136:55: (iv_ruleXAndExpression= ruleXAndExpression EOF )
+ // InternalOXtype.g:1137:2: iv_ruleXAndExpression= ruleXAndExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXAndExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXAndExpression=ruleXAndExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXAndExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXAndExpression"
+
+
+ // $ANTLR start "ruleXAndExpression"
+ // InternalOXtype.g:1143:1: ruleXAndExpression returns [EObject current=null] : (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* ) ;
+ public final EObject ruleXAndExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_XEqualityExpression_0 = null;
+
+ EObject lv_rightOperand_3_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:1149:2: ( (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* ) )
+ // InternalOXtype.g:1150:2: (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* )
+ {
+ // InternalOXtype.g:1150:2: (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* )
+ // InternalOXtype.g:1151:3: this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_23);
+ this_XEqualityExpression_0=ruleXEqualityExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XEqualityExpression_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // InternalOXtype.g:1159:3: ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )*
+ loop22:
+ do {
+ int alt22=2;
+ int LA22_0 = input.LA(1);
+
+ if ( (LA22_0==36) ) {
+ int LA22_2 = input.LA(2);
+
+ if ( (synpred9_InternalOXtype()) ) {
+ alt22=1;
+ }
+
+
+ }
+
+
+ switch (alt22) {
+ case 1 :
+ // InternalOXtype.g:1160:4: ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) )
+ {
+ // InternalOXtype.g:1160:4: ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) )
+ // InternalOXtype.g:1161:5: ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) )
+ {
+ // InternalOXtype.g:1171:5: ( () ( ( ruleOpAnd ) ) )
+ // InternalOXtype.g:1172:6: () ( ( ruleOpAnd ) )
+ {
+ // InternalOXtype.g:1172:6: ()
+ // InternalOXtype.g:1173:7:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:1179:6: ( ( ruleOpAnd ) )
+ // InternalOXtype.g:1180:7: ( ruleOpAnd )
+ {
+ // InternalOXtype.g:1180:7: ( ruleOpAnd )
+ // InternalOXtype.g:1181:8: ruleOpAnd
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXAndExpressionRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+
+ }
+ pushFollow(FOLLOW_13);
+ ruleOpAnd();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:1197:4: ( (lv_rightOperand_3_0= ruleXEqualityExpression ) )
+ // InternalOXtype.g:1198:5: (lv_rightOperand_3_0= ruleXEqualityExpression )
+ {
+ // InternalOXtype.g:1198:5: (lv_rightOperand_3_0= ruleXEqualityExpression )
+ // InternalOXtype.g:1199:6: lv_rightOperand_3_0= ruleXEqualityExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_23);
+ lv_rightOperand_3_0=ruleXEqualityExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXAndExpressionRule());
+ }
+ set(
+ current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XEqualityExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop22;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXAndExpression"
+
+
+ // $ANTLR start "entryRuleOpAnd"
+ // InternalOXtype.g:1221:1: entryRuleOpAnd returns [String current=null] : iv_ruleOpAnd= ruleOpAnd EOF ;
+ public final String entryRuleOpAnd() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleOpAnd = null;
+
+
+ try {
+ // InternalOXtype.g:1221:45: (iv_ruleOpAnd= ruleOpAnd EOF )
+ // InternalOXtype.g:1222:2: iv_ruleOpAnd= ruleOpAnd EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getOpAndRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleOpAnd=ruleOpAnd();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleOpAnd.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleOpAnd"
+
+
+ // $ANTLR start "ruleOpAnd"
+ // InternalOXtype.g:1228:1: ruleOpAnd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= '&&' ;
+ public final AntlrDatatypeRuleToken ruleOpAnd() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token kw=null;
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:1234:2: (kw= '&&' )
+ // InternalOXtype.g:1235:2: kw= '&&'
+ {
+ kw=(Token)match(input,36,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword());
+
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleOpAnd"
+
+
+ // $ANTLR start "entryRuleXEqualityExpression"
+ // InternalOXtype.g:1243:1: entryRuleXEqualityExpression returns [EObject current=null] : iv_ruleXEqualityExpression= ruleXEqualityExpression EOF ;
+ public final EObject entryRuleXEqualityExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXEqualityExpression = null;
+
+
+ try {
+ // InternalOXtype.g:1243:60: (iv_ruleXEqualityExpression= ruleXEqualityExpression EOF )
+ // InternalOXtype.g:1244:2: iv_ruleXEqualityExpression= ruleXEqualityExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXEqualityExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXEqualityExpression=ruleXEqualityExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXEqualityExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXEqualityExpression"
+
+
+ // $ANTLR start "ruleXEqualityExpression"
+ // InternalOXtype.g:1250:1: ruleXEqualityExpression returns [EObject current=null] : (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* ) ;
+ public final EObject ruleXEqualityExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_XRelationalExpression_0 = null;
+
+ EObject lv_rightOperand_3_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:1256:2: ( (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* ) )
+ // InternalOXtype.g:1257:2: (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* )
+ {
+ // InternalOXtype.g:1257:2: (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* )
+ // InternalOXtype.g:1258:3: this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_24);
+ this_XRelationalExpression_0=ruleXRelationalExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XRelationalExpression_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // InternalOXtype.g:1266:3: ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )*
+ loop23:
+ do {
+ int alt23=2;
+ switch ( input.LA(1) ) {
+ case 37:
+ {
+ int LA23_2 = input.LA(2);
+
+ if ( (synpred10_InternalOXtype()) ) {
+ alt23=1;
+ }
+
+
+ }
+ break;
+ case 38:
+ {
+ int LA23_3 = input.LA(2);
+
+ if ( (synpred10_InternalOXtype()) ) {
+ alt23=1;
+ }
+
+
+ }
+ break;
+ case 39:
+ {
+ int LA23_4 = input.LA(2);
+
+ if ( (synpred10_InternalOXtype()) ) {
+ alt23=1;
+ }
+
+
+ }
+ break;
+ case 40:
+ {
+ int LA23_5 = input.LA(2);
+
+ if ( (synpred10_InternalOXtype()) ) {
+ alt23=1;
+ }
+
+
+ }
+ break;
+
+ }
+
+ switch (alt23) {
+ case 1 :
+ // InternalOXtype.g:1267:4: ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) )
+ {
+ // InternalOXtype.g:1267:4: ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) )
+ // InternalOXtype.g:1268:5: ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) )
+ {
+ // InternalOXtype.g:1278:5: ( () ( ( ruleOpEquality ) ) )
+ // InternalOXtype.g:1279:6: () ( ( ruleOpEquality ) )
+ {
+ // InternalOXtype.g:1279:6: ()
+ // InternalOXtype.g:1280:7:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:1286:6: ( ( ruleOpEquality ) )
+ // InternalOXtype.g:1287:7: ( ruleOpEquality )
+ {
+ // InternalOXtype.g:1287:7: ( ruleOpEquality )
+ // InternalOXtype.g:1288:8: ruleOpEquality
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXEqualityExpressionRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+
+ }
+ pushFollow(FOLLOW_13);
+ ruleOpEquality();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:1304:4: ( (lv_rightOperand_3_0= ruleXRelationalExpression ) )
+ // InternalOXtype.g:1305:5: (lv_rightOperand_3_0= ruleXRelationalExpression )
+ {
+ // InternalOXtype.g:1305:5: (lv_rightOperand_3_0= ruleXRelationalExpression )
+ // InternalOXtype.g:1306:6: lv_rightOperand_3_0= ruleXRelationalExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_24);
+ lv_rightOperand_3_0=ruleXRelationalExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXEqualityExpressionRule());
+ }
+ set(
+ current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XRelationalExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop23;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXEqualityExpression"
+
+
+ // $ANTLR start "entryRuleOpEquality"
+ // InternalOXtype.g:1328:1: entryRuleOpEquality returns [String current=null] : iv_ruleOpEquality= ruleOpEquality EOF ;
+ public final String entryRuleOpEquality() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleOpEquality = null;
+
+
+ try {
+ // InternalOXtype.g:1328:50: (iv_ruleOpEquality= ruleOpEquality EOF )
+ // InternalOXtype.g:1329:2: iv_ruleOpEquality= ruleOpEquality EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getOpEqualityRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleOpEquality=ruleOpEquality();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleOpEquality.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleOpEquality"
+
+
+ // $ANTLR start "ruleOpEquality"
+ // InternalOXtype.g:1335:1: ruleOpEquality returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' ) ;
+ public final AntlrDatatypeRuleToken ruleOpEquality() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token kw=null;
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:1341:2: ( (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' ) )
+ // InternalOXtype.g:1342:2: (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' )
+ {
+ // InternalOXtype.g:1342:2: (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' )
+ int alt24=4;
+ switch ( input.LA(1) ) {
+ case 37:
+ {
+ alt24=1;
+ }
+ break;
+ case 38:
+ {
+ alt24=2;
+ }
+ break;
+ case 39:
+ {
+ alt24=3;
+ }
+ break;
+ case 40:
+ {
+ alt24=4;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 24, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt24) {
+ case 1 :
+ // InternalOXtype.g:1343:3: kw= '=='
+ {
+ kw=(Token)match(input,37,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:1349:3: kw= '!='
+ {
+ kw=(Token)match(input,38,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1());
+
+ }
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:1355:3: kw= '==='
+ {
+ kw=(Token)match(input,39,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2());
+
+ }
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:1361:3: kw= '!=='
+ {
+ kw=(Token)match(input,40,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleOpEquality"
+
+
+ // $ANTLR start "entryRuleXRelationalExpression"
+ // InternalOXtype.g:1370:1: entryRuleXRelationalExpression returns [EObject current=null] : iv_ruleXRelationalExpression= ruleXRelationalExpression EOF ;
+ public final EObject entryRuleXRelationalExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXRelationalExpression = null;
+
+
+ try {
+ // InternalOXtype.g:1370:62: (iv_ruleXRelationalExpression= ruleXRelationalExpression EOF )
+ // InternalOXtype.g:1371:2: iv_ruleXRelationalExpression= ruleXRelationalExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXRelationalExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXRelationalExpression=ruleXRelationalExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXRelationalExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXRelationalExpression"
+
+
+ // $ANTLR start "ruleXRelationalExpression"
+ // InternalOXtype.g:1377:1: ruleXRelationalExpression returns [EObject current=null] : (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* ) ;
+ public final EObject ruleXRelationalExpression() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_2=null;
+ EObject this_XOtherOperatorExpression_0 = null;
+
+ EObject lv_type_3_0 = null;
+
+ EObject lv_rightOperand_6_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:1383:2: ( (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* ) )
+ // InternalOXtype.g:1384:2: (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* )
+ {
+ // InternalOXtype.g:1384:2: (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* )
+ // InternalOXtype.g:1385:3: this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_25);
+ this_XOtherOperatorExpression_0=ruleXOtherOperatorExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XOtherOperatorExpression_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // InternalOXtype.g:1393:3: ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )*
+ loop25:
+ do {
+ int alt25=3;
+ switch ( input.LA(1) ) {
+ case 32:
+ {
+ int LA25_2 = input.LA(2);
+
+ if ( (synpred12_InternalOXtype()) ) {
+ alt25=2;
+ }
+
+
+ }
+ break;
+ case 33:
+ {
+ int LA25_3 = input.LA(2);
+
+ if ( (synpred12_InternalOXtype()) ) {
+ alt25=2;
+ }
+
+
+ }
+ break;
+ case 41:
+ {
+ int LA25_4 = input.LA(2);
+
+ if ( (synpred11_InternalOXtype()) ) {
+ alt25=1;
+ }
+
+
+ }
+ break;
+ case 34:
+ {
+ int LA25_5 = input.LA(2);
+
+ if ( (synpred12_InternalOXtype()) ) {
+ alt25=2;
+ }
+
+
+ }
+ break;
+
+ }
+
+ switch (alt25) {
+ case 1 :
+ // InternalOXtype.g:1394:4: ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )
+ {
+ // InternalOXtype.g:1394:4: ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )
+ // InternalOXtype.g:1395:5: ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) )
+ {
+ // InternalOXtype.g:1395:5: ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) )
+ // InternalOXtype.g:1396:6: ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' )
+ {
+ // InternalOXtype.g:1402:6: ( () otherlv_2= 'instanceof' )
+ // InternalOXtype.g:1403:7: () otherlv_2= 'instanceof'
+ {
+ // InternalOXtype.g:1403:7: ()
+ // InternalOXtype.g:1404:8:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_2=(Token)match(input,41,FOLLOW_26); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1());
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:1416:5: ( (lv_type_3_0= ruleJvmTypeReference ) )
+ // InternalOXtype.g:1417:6: (lv_type_3_0= ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:1417:6: (lv_type_3_0= ruleJvmTypeReference )
+ // InternalOXtype.g:1418:7: lv_type_3_0= ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0());
+
+ }
+ pushFollow(FOLLOW_25);
+ lv_type_3_0=ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule());
+ }
+ set(
+ current,
+ "type",
+ lv_type_3_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:1437:4: ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) )
+ {
+ // InternalOXtype.g:1437:4: ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) )
+ // InternalOXtype.g:1438:5: ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) )
+ {
+ // InternalOXtype.g:1438:5: ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) )
+ // InternalOXtype.g:1439:6: ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) )
+ {
+ // InternalOXtype.g:1449:6: ( () ( ( ruleOpCompare ) ) )
+ // InternalOXtype.g:1450:7: () ( ( ruleOpCompare ) )
+ {
+ // InternalOXtype.g:1450:7: ()
+ // InternalOXtype.g:1451:8:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:1457:7: ( ( ruleOpCompare ) )
+ // InternalOXtype.g:1458:8: ( ruleOpCompare )
+ {
+ // InternalOXtype.g:1458:8: ( ruleOpCompare )
+ // InternalOXtype.g:1459:9: ruleOpCompare
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXRelationalExpressionRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0());
+
+ }
+ pushFollow(FOLLOW_13);
+ ruleOpCompare();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:1475:5: ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) )
+ // InternalOXtype.g:1476:6: (lv_rightOperand_6_0= ruleXOtherOperatorExpression )
+ {
+ // InternalOXtype.g:1476:6: (lv_rightOperand_6_0= ruleXOtherOperatorExpression )
+ // InternalOXtype.g:1477:7: lv_rightOperand_6_0= ruleXOtherOperatorExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_25);
+ lv_rightOperand_6_0=ruleXOtherOperatorExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule());
+ }
+ set(
+ current,
+ "rightOperand",
+ lv_rightOperand_6_0,
+ "org.eclipse.xtext.xbase.Xbase.XOtherOperatorExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop25;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXRelationalExpression"
+
+
+ // $ANTLR start "entryRuleOpCompare"
+ // InternalOXtype.g:1500:1: entryRuleOpCompare returns [String current=null] : iv_ruleOpCompare= ruleOpCompare EOF ;
+ public final String entryRuleOpCompare() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleOpCompare = null;
+
+
+ try {
+ // InternalOXtype.g:1500:49: (iv_ruleOpCompare= ruleOpCompare EOF )
+ // InternalOXtype.g:1501:2: iv_ruleOpCompare= ruleOpCompare EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getOpCompareRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleOpCompare=ruleOpCompare();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleOpCompare.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleOpCompare"
+
+
+ // $ANTLR start "ruleOpCompare"
+ // InternalOXtype.g:1507:1: ruleOpCompare returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' ) ;
+ public final AntlrDatatypeRuleToken ruleOpCompare() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token kw=null;
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:1513:2: ( (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' ) )
+ // InternalOXtype.g:1514:2: (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' )
+ {
+ // InternalOXtype.g:1514:2: (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' )
+ int alt26=4;
+ switch ( input.LA(1) ) {
+ case 34:
+ {
+ alt26=1;
+ }
+ break;
+ case 32:
+ {
+ int LA26_2 = input.LA(2);
+
+ if ( (LA26_2==EOF||(LA26_2>=RULE_STRING && LA26_2<=RULE_ID)||(LA26_2>=13 && LA26_2<=15)||LA26_2==20||(LA26_2>=24 && LA26_2<=25)||LA26_2==32||(LA26_2>=48 && LA26_2<=49)||LA26_2==53||LA26_2==60||LA26_2==63||LA26_2==65||(LA26_2>=69 && LA26_2<=71)||(LA26_2>=74 && LA26_2<=83)||LA26_2==85) ) {
+ alt26=4;
+ }
+ else if ( (LA26_2==23) ) {
+ alt26=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 26, 2, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case 33:
+ {
+ alt26=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 26, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt26) {
+ case 1 :
+ // InternalOXtype.g:1515:3: kw= '>='
+ {
+ kw=(Token)match(input,34,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:1521:3: (kw= '<' kw= '=' )
+ {
+ // InternalOXtype.g:1521:3: (kw= '<' kw= '=' )
+ // InternalOXtype.g:1522:4: kw= '<' kw= '='
+ {
+ kw=(Token)match(input,32,FOLLOW_12); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0());
+
+ }
+ kw=(Token)match(input,23,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1());
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:1534:3: kw= '>'
+ {
+ kw=(Token)match(input,33,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2());
+
+ }
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:1540:3: kw= '<'
+ {
+ kw=(Token)match(input,32,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleOpCompare"
+
+
+ // $ANTLR start "entryRuleXOtherOperatorExpression"
+ // InternalOXtype.g:1549:1: entryRuleXOtherOperatorExpression returns [EObject current=null] : iv_ruleXOtherOperatorExpression= ruleXOtherOperatorExpression EOF ;
+ public final EObject entryRuleXOtherOperatorExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXOtherOperatorExpression = null;
+
+
+ try {
+ // InternalOXtype.g:1549:65: (iv_ruleXOtherOperatorExpression= ruleXOtherOperatorExpression EOF )
+ // InternalOXtype.g:1550:2: iv_ruleXOtherOperatorExpression= ruleXOtherOperatorExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXOtherOperatorExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXOtherOperatorExpression=ruleXOtherOperatorExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXOtherOperatorExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXOtherOperatorExpression"
+
+
+ // $ANTLR start "ruleXOtherOperatorExpression"
+ // InternalOXtype.g:1556:1: ruleXOtherOperatorExpression returns [EObject current=null] : (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* ) ;
+ public final EObject ruleXOtherOperatorExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_XAdditiveExpression_0 = null;
+
+ EObject lv_rightOperand_3_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:1562:2: ( (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* ) )
+ // InternalOXtype.g:1563:2: (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* )
+ {
+ // InternalOXtype.g:1563:2: (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* )
+ // InternalOXtype.g:1564:3: this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_27);
+ this_XAdditiveExpression_0=ruleXAdditiveExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XAdditiveExpression_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // InternalOXtype.g:1572:3: ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )*
+ loop27:
+ do {
+ int alt27=2;
+ alt27 = dfa27.predict(input);
+ switch (alt27) {
+ case 1 :
+ // InternalOXtype.g:1573:4: ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) )
+ {
+ // InternalOXtype.g:1573:4: ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) )
+ // InternalOXtype.g:1574:5: ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) )
+ {
+ // InternalOXtype.g:1584:5: ( () ( ( ruleOpOther ) ) )
+ // InternalOXtype.g:1585:6: () ( ( ruleOpOther ) )
+ {
+ // InternalOXtype.g:1585:6: ()
+ // InternalOXtype.g:1586:7:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:1592:6: ( ( ruleOpOther ) )
+ // InternalOXtype.g:1593:7: ( ruleOpOther )
+ {
+ // InternalOXtype.g:1593:7: ( ruleOpOther )
+ // InternalOXtype.g:1594:8: ruleOpOther
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXOtherOperatorExpressionRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+
+ }
+ pushFollow(FOLLOW_13);
+ ruleOpOther();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:1610:4: ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) )
+ // InternalOXtype.g:1611:5: (lv_rightOperand_3_0= ruleXAdditiveExpression )
+ {
+ // InternalOXtype.g:1611:5: (lv_rightOperand_3_0= ruleXAdditiveExpression )
+ // InternalOXtype.g:1612:6: lv_rightOperand_3_0= ruleXAdditiveExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_27);
+ lv_rightOperand_3_0=ruleXAdditiveExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXOtherOperatorExpressionRule());
+ }
+ set(
+ current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XAdditiveExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop27;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXOtherOperatorExpression"
+
+
+ // $ANTLR start "entryRuleOpOther"
+ // InternalOXtype.g:1634:1: entryRuleOpOther returns [String current=null] : iv_ruleOpOther= ruleOpOther EOF ;
+ public final String entryRuleOpOther() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleOpOther = null;
+
+
+ try {
+ // InternalOXtype.g:1634:47: (iv_ruleOpOther= ruleOpOther EOF )
+ // InternalOXtype.g:1635:2: iv_ruleOpOther= ruleOpOther EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getOpOtherRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleOpOther=ruleOpOther();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleOpOther.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleOpOther"
+
+
+ // $ANTLR start "ruleOpOther"
+ // InternalOXtype.g:1641:1: ruleOpOther returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' ) ;
+ public final AntlrDatatypeRuleToken ruleOpOther() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token kw=null;
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:1647:2: ( (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' ) )
+ // InternalOXtype.g:1648:2: (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' )
+ {
+ // InternalOXtype.g:1648:2: (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' )
+ int alt30=9;
+ alt30 = dfa30.predict(input);
+ switch (alt30) {
+ case 1 :
+ // InternalOXtype.g:1649:3: kw= '->'
+ {
+ kw=(Token)match(input,42,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:1655:3: kw= '..<'
+ {
+ kw=(Token)match(input,43,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1());
+
+ }
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:1661:3: (kw= '>' kw= '..' )
+ {
+ // InternalOXtype.g:1661:3: (kw= '>' kw= '..' )
+ // InternalOXtype.g:1662:4: kw= '>' kw= '..'
+ {
+ kw=(Token)match(input,33,FOLLOW_28); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0());
+
+ }
+ kw=(Token)match(input,44,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1());
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:1674:3: kw= '..'
+ {
+ kw=(Token)match(input,44,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3());
+
+ }
+
+ }
+ break;
+ case 5 :
+ // InternalOXtype.g:1680:3: kw= '=>'
+ {
+ kw=(Token)match(input,45,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4());
+
+ }
+
+ }
+ break;
+ case 6 :
+ // InternalOXtype.g:1686:3: (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) )
+ {
+ // InternalOXtype.g:1686:3: (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) )
+ // InternalOXtype.g:1687:4: kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' )
+ {
+ kw=(Token)match(input,33,FOLLOW_29); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0());
+
+ }
+ // InternalOXtype.g:1692:4: ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' )
+ int alt28=2;
+ int LA28_0 = input.LA(1);
+
+ if ( (LA28_0==33) ) {
+ int LA28_1 = input.LA(2);
+
+ if ( (LA28_1==EOF||(LA28_1>=RULE_STRING && LA28_1<=RULE_ID)||(LA28_1>=13 && LA28_1<=15)||LA28_1==20||(LA28_1>=24 && LA28_1<=25)||LA28_1==32||(LA28_1>=48 && LA28_1<=49)||LA28_1==53||LA28_1==60||LA28_1==63||LA28_1==65||(LA28_1>=69 && LA28_1<=71)||(LA28_1>=74 && LA28_1<=83)||LA28_1==85) ) {
+ alt28=2;
+ }
+ else if ( (LA28_1==33) && (synpred14_InternalOXtype())) {
+ alt28=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 28, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 28, 0, input);
+
+ throw nvae;
+ }
+ switch (alt28) {
+ case 1 :
+ // InternalOXtype.g:1693:5: ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) )
+ {
+ // InternalOXtype.g:1693:5: ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) )
+ // InternalOXtype.g:1694:6: ( ( '>' '>' ) )=> (kw= '>' kw= '>' )
+ {
+ // InternalOXtype.g:1699:6: (kw= '>' kw= '>' )
+ // InternalOXtype.g:1700:7: kw= '>' kw= '>'
+ {
+ kw=(Token)match(input,33,FOLLOW_29); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0());
+
+ }
+ kw=(Token)match(input,33,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1());
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:1713:5: kw= '>'
+ {
+ kw=(Token)match(input,33,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 7 :
+ // InternalOXtype.g:1721:3: (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) )
+ {
+ // InternalOXtype.g:1721:3: (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) )
+ // InternalOXtype.g:1722:4: kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' )
+ {
+ kw=(Token)match(input,32,FOLLOW_30); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0());
+
+ }
+ // InternalOXtype.g:1727:4: ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' )
+ int alt29=3;
+ int LA29_0 = input.LA(1);
+
+ if ( (LA29_0==32) ) {
+ int LA29_1 = input.LA(2);
+
+ if ( (synpred15_InternalOXtype()) ) {
+ alt29=1;
+ }
+ else if ( (true) ) {
+ alt29=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 29, 1, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA29_0==45) ) {
+ alt29=3;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 29, 0, input);
+
+ throw nvae;
+ }
+ switch (alt29) {
+ case 1 :
+ // InternalOXtype.g:1728:5: ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) )
+ {
+ // InternalOXtype.g:1728:5: ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) )
+ // InternalOXtype.g:1729:6: ( ( '<' '<' ) )=> (kw= '<' kw= '<' )
+ {
+ // InternalOXtype.g:1734:6: (kw= '<' kw= '<' )
+ // InternalOXtype.g:1735:7: kw= '<' kw= '<'
+ {
+ kw=(Token)match(input,32,FOLLOW_19); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0());
+
+ }
+ kw=(Token)match(input,32,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1());
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:1748:5: kw= '<'
+ {
+ kw=(Token)match(input,32,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1());
+
+ }
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:1754:5: kw= '=>'
+ {
+ kw=(Token)match(input,45,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 8 :
+ // InternalOXtype.g:1762:3: kw= '<>'
+ {
+ kw=(Token)match(input,46,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7());
+
+ }
+
+ }
+ break;
+ case 9 :
+ // InternalOXtype.g:1768:3: kw= '?:'
+ {
+ kw=(Token)match(input,47,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleOpOther"
+
+
+ // $ANTLR start "entryRuleXAdditiveExpression"
+ // InternalOXtype.g:1777:1: entryRuleXAdditiveExpression returns [EObject current=null] : iv_ruleXAdditiveExpression= ruleXAdditiveExpression EOF ;
+ public final EObject entryRuleXAdditiveExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXAdditiveExpression = null;
+
+
+ try {
+ // InternalOXtype.g:1777:60: (iv_ruleXAdditiveExpression= ruleXAdditiveExpression EOF )
+ // InternalOXtype.g:1778:2: iv_ruleXAdditiveExpression= ruleXAdditiveExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXAdditiveExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXAdditiveExpression=ruleXAdditiveExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXAdditiveExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXAdditiveExpression"
+
+
+ // $ANTLR start "ruleXAdditiveExpression"
+ // InternalOXtype.g:1784:1: ruleXAdditiveExpression returns [EObject current=null] : (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* ) ;
+ public final EObject ruleXAdditiveExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_XMultiplicativeExpression_0 = null;
+
+ EObject lv_rightOperand_3_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:1790:2: ( (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* ) )
+ // InternalOXtype.g:1791:2: (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* )
+ {
+ // InternalOXtype.g:1791:2: (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* )
+ // InternalOXtype.g:1792:3: this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_31);
+ this_XMultiplicativeExpression_0=ruleXMultiplicativeExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XMultiplicativeExpression_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // InternalOXtype.g:1800:3: ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )*
+ loop31:
+ do {
+ int alt31=2;
+ int LA31_0 = input.LA(1);
+
+ if ( (LA31_0==48) ) {
+ int LA31_2 = input.LA(2);
+
+ if ( (synpred16_InternalOXtype()) ) {
+ alt31=1;
+ }
+
+
+ }
+ else if ( (LA31_0==49) ) {
+ int LA31_3 = input.LA(2);
+
+ if ( (synpred16_InternalOXtype()) ) {
+ alt31=1;
+ }
+
+
+ }
+
+
+ switch (alt31) {
+ case 1 :
+ // InternalOXtype.g:1801:4: ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) )
+ {
+ // InternalOXtype.g:1801:4: ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) )
+ // InternalOXtype.g:1802:5: ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) )
+ {
+ // InternalOXtype.g:1812:5: ( () ( ( ruleOpAdd ) ) )
+ // InternalOXtype.g:1813:6: () ( ( ruleOpAdd ) )
+ {
+ // InternalOXtype.g:1813:6: ()
+ // InternalOXtype.g:1814:7:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:1820:6: ( ( ruleOpAdd ) )
+ // InternalOXtype.g:1821:7: ( ruleOpAdd )
+ {
+ // InternalOXtype.g:1821:7: ( ruleOpAdd )
+ // InternalOXtype.g:1822:8: ruleOpAdd
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXAdditiveExpressionRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+
+ }
+ pushFollow(FOLLOW_13);
+ ruleOpAdd();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:1838:4: ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) )
+ // InternalOXtype.g:1839:5: (lv_rightOperand_3_0= ruleXMultiplicativeExpression )
+ {
+ // InternalOXtype.g:1839:5: (lv_rightOperand_3_0= ruleXMultiplicativeExpression )
+ // InternalOXtype.g:1840:6: lv_rightOperand_3_0= ruleXMultiplicativeExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_31);
+ lv_rightOperand_3_0=ruleXMultiplicativeExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXAdditiveExpressionRule());
+ }
+ set(
+ current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XMultiplicativeExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop31;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXAdditiveExpression"
+
+
+ // $ANTLR start "entryRuleOpAdd"
+ // InternalOXtype.g:1862:1: entryRuleOpAdd returns [String current=null] : iv_ruleOpAdd= ruleOpAdd EOF ;
+ public final String entryRuleOpAdd() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleOpAdd = null;
+
+
+ try {
+ // InternalOXtype.g:1862:45: (iv_ruleOpAdd= ruleOpAdd EOF )
+ // InternalOXtype.g:1863:2: iv_ruleOpAdd= ruleOpAdd EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getOpAddRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleOpAdd=ruleOpAdd();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleOpAdd.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleOpAdd"
+
+
+ // $ANTLR start "ruleOpAdd"
+ // InternalOXtype.g:1869:1: ruleOpAdd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '+' | kw= '-' ) ;
+ public final AntlrDatatypeRuleToken ruleOpAdd() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token kw=null;
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:1875:2: ( (kw= '+' | kw= '-' ) )
+ // InternalOXtype.g:1876:2: (kw= '+' | kw= '-' )
+ {
+ // InternalOXtype.g:1876:2: (kw= '+' | kw= '-' )
+ int alt32=2;
+ int LA32_0 = input.LA(1);
+
+ if ( (LA32_0==48) ) {
+ alt32=1;
+ }
+ else if ( (LA32_0==49) ) {
+ alt32=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 32, 0, input);
+
+ throw nvae;
+ }
+ switch (alt32) {
+ case 1 :
+ // InternalOXtype.g:1877:3: kw= '+'
+ {
+ kw=(Token)match(input,48,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpAddAccess().getPlusSignKeyword_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:1883:3: kw= '-'
+ {
+ kw=(Token)match(input,49,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleOpAdd"
+
+
+ // $ANTLR start "entryRuleXMultiplicativeExpression"
+ // InternalOXtype.g:1892:1: entryRuleXMultiplicativeExpression returns [EObject current=null] : iv_ruleXMultiplicativeExpression= ruleXMultiplicativeExpression EOF ;
+ public final EObject entryRuleXMultiplicativeExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXMultiplicativeExpression = null;
+
+
+ try {
+ // InternalOXtype.g:1892:66: (iv_ruleXMultiplicativeExpression= ruleXMultiplicativeExpression EOF )
+ // InternalOXtype.g:1893:2: iv_ruleXMultiplicativeExpression= ruleXMultiplicativeExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXMultiplicativeExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXMultiplicativeExpression=ruleXMultiplicativeExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXMultiplicativeExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXMultiplicativeExpression"
+
+
+ // $ANTLR start "ruleXMultiplicativeExpression"
+ // InternalOXtype.g:1899:1: ruleXMultiplicativeExpression returns [EObject current=null] : (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* ) ;
+ public final EObject ruleXMultiplicativeExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_XUnaryOperation_0 = null;
+
+ EObject lv_rightOperand_3_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:1905:2: ( (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* ) )
+ // InternalOXtype.g:1906:2: (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* )
+ {
+ // InternalOXtype.g:1906:2: (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* )
+ // InternalOXtype.g:1907:3: this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_32);
+ this_XUnaryOperation_0=ruleXUnaryOperation();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XUnaryOperation_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // InternalOXtype.g:1915:3: ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )*
+ loop33:
+ do {
+ int alt33=2;
+ switch ( input.LA(1) ) {
+ case 16:
+ {
+ int LA33_2 = input.LA(2);
+
+ if ( (synpred17_InternalOXtype()) ) {
+ alt33=1;
+ }
+
+
+ }
+ break;
+ case 50:
+ {
+ int LA33_3 = input.LA(2);
+
+ if ( (synpred17_InternalOXtype()) ) {
+ alt33=1;
+ }
+
+
+ }
+ break;
+ case 51:
+ {
+ int LA33_4 = input.LA(2);
+
+ if ( (synpred17_InternalOXtype()) ) {
+ alt33=1;
+ }
+
+
+ }
+ break;
+ case 52:
+ {
+ int LA33_5 = input.LA(2);
+
+ if ( (synpred17_InternalOXtype()) ) {
+ alt33=1;
+ }
+
+
+ }
+ break;
+
+ }
+
+ switch (alt33) {
+ case 1 :
+ // InternalOXtype.g:1916:4: ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) )
+ {
+ // InternalOXtype.g:1916:4: ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) )
+ // InternalOXtype.g:1917:5: ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) )
+ {
+ // InternalOXtype.g:1927:5: ( () ( ( ruleOpMulti ) ) )
+ // InternalOXtype.g:1928:6: () ( ( ruleOpMulti ) )
+ {
+ // InternalOXtype.g:1928:6: ()
+ // InternalOXtype.g:1929:7:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:1935:6: ( ( ruleOpMulti ) )
+ // InternalOXtype.g:1936:7: ( ruleOpMulti )
+ {
+ // InternalOXtype.g:1936:7: ( ruleOpMulti )
+ // InternalOXtype.g:1937:8: ruleOpMulti
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXMultiplicativeExpressionRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+
+ }
+ pushFollow(FOLLOW_13);
+ ruleOpMulti();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:1953:4: ( (lv_rightOperand_3_0= ruleXUnaryOperation ) )
+ // InternalOXtype.g:1954:5: (lv_rightOperand_3_0= ruleXUnaryOperation )
+ {
+ // InternalOXtype.g:1954:5: (lv_rightOperand_3_0= ruleXUnaryOperation )
+ // InternalOXtype.g:1955:6: lv_rightOperand_3_0= ruleXUnaryOperation
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_32);
+ lv_rightOperand_3_0=ruleXUnaryOperation();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXMultiplicativeExpressionRule());
+ }
+ set(
+ current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XUnaryOperation");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop33;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXMultiplicativeExpression"
+
+
+ // $ANTLR start "entryRuleOpMulti"
+ // InternalOXtype.g:1977:1: entryRuleOpMulti returns [String current=null] : iv_ruleOpMulti= ruleOpMulti EOF ;
+ public final String entryRuleOpMulti() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleOpMulti = null;
+
+
+ try {
+ // InternalOXtype.g:1977:47: (iv_ruleOpMulti= ruleOpMulti EOF )
+ // InternalOXtype.g:1978:2: iv_ruleOpMulti= ruleOpMulti EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getOpMultiRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleOpMulti=ruleOpMulti();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleOpMulti.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleOpMulti"
+
+
+ // $ANTLR start "ruleOpMulti"
+ // InternalOXtype.g:1984:1: ruleOpMulti returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '*' | kw= '**' | kw= '/' | kw= '%' ) ;
+ public final AntlrDatatypeRuleToken ruleOpMulti() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token kw=null;
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:1990:2: ( (kw= '*' | kw= '**' | kw= '/' | kw= '%' ) )
+ // InternalOXtype.g:1991:2: (kw= '*' | kw= '**' | kw= '/' | kw= '%' )
+ {
+ // InternalOXtype.g:1991:2: (kw= '*' | kw= '**' | kw= '/' | kw= '%' )
+ int alt34=4;
+ switch ( input.LA(1) ) {
+ case 16:
+ {
+ alt34=1;
+ }
+ break;
+ case 50:
+ {
+ alt34=2;
+ }
+ break;
+ case 51:
+ {
+ alt34=3;
+ }
+ break;
+ case 52:
+ {
+ alt34=4;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 34, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt34) {
+ case 1 :
+ // InternalOXtype.g:1992:3: kw= '*'
+ {
+ kw=(Token)match(input,16,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskKeyword_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:1998:3: kw= '**'
+ {
+ kw=(Token)match(input,50,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1());
+
+ }
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:2004:3: kw= '/'
+ {
+ kw=(Token)match(input,51,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAccess().getSolidusKeyword_2());
+
+ }
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:2010:3: kw= '%'
+ {
+ kw=(Token)match(input,52,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAccess().getPercentSignKeyword_3());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleOpMulti"
+
+
+ // $ANTLR start "entryRuleXUnaryOperation"
+ // InternalOXtype.g:2019:1: entryRuleXUnaryOperation returns [EObject current=null] : iv_ruleXUnaryOperation= ruleXUnaryOperation EOF ;
+ public final EObject entryRuleXUnaryOperation() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXUnaryOperation = null;
+
+
+ try {
+ // InternalOXtype.g:2019:56: (iv_ruleXUnaryOperation= ruleXUnaryOperation EOF )
+ // InternalOXtype.g:2020:2: iv_ruleXUnaryOperation= ruleXUnaryOperation EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXUnaryOperationRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXUnaryOperation=ruleXUnaryOperation();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXUnaryOperation;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXUnaryOperation"
+
+
+ // $ANTLR start "ruleXUnaryOperation"
+ // InternalOXtype.g:2026:1: ruleXUnaryOperation returns [EObject current=null] : ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression ) ;
+ public final EObject ruleXUnaryOperation() throws RecognitionException {
+ EObject current = null;
+
+ EObject lv_operand_2_0 = null;
+
+ EObject this_XCastedExpression_3 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:2032:2: ( ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression ) )
+ // InternalOXtype.g:2033:2: ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression )
+ {
+ // InternalOXtype.g:2033:2: ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression )
+ int alt35=2;
+ int LA35_0 = input.LA(1);
+
+ if ( ((LA35_0>=48 && LA35_0<=49)||LA35_0==53) ) {
+ alt35=1;
+ }
+ else if ( ((LA35_0>=RULE_STRING && LA35_0<=RULE_ID)||(LA35_0>=13 && LA35_0<=15)||LA35_0==20||(LA35_0>=24 && LA35_0<=25)||LA35_0==32||LA35_0==60||LA35_0==63||LA35_0==65||(LA35_0>=69 && LA35_0<=71)||(LA35_0>=74 && LA35_0<=83)||LA35_0==85) ) {
+ alt35=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 35, 0, input);
+
+ throw nvae;
+ }
+ switch (alt35) {
+ case 1 :
+ // InternalOXtype.g:2034:3: ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) )
+ {
+ // InternalOXtype.g:2034:3: ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) )
+ // InternalOXtype.g:2035:4: () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) )
+ {
+ // InternalOXtype.g:2035:4: ()
+ // InternalOXtype.g:2036:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:2042:4: ( ( ruleOpUnary ) )
+ // InternalOXtype.g:2043:5: ( ruleOpUnary )
+ {
+ // InternalOXtype.g:2043:5: ( ruleOpUnary )
+ // InternalOXtype.g:2044:6: ruleOpUnary
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXUnaryOperationRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0());
+
+ }
+ pushFollow(FOLLOW_13);
+ ruleOpUnary();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:2058:4: ( (lv_operand_2_0= ruleXUnaryOperation ) )
+ // InternalOXtype.g:2059:5: (lv_operand_2_0= ruleXUnaryOperation )
+ {
+ // InternalOXtype.g:2059:5: (lv_operand_2_0= ruleXUnaryOperation )
+ // InternalOXtype.g:2060:6: lv_operand_2_0= ruleXUnaryOperation
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_operand_2_0=ruleXUnaryOperation();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXUnaryOperationRule());
+ }
+ set(
+ current,
+ "operand",
+ lv_operand_2_0,
+ "org.eclipse.xtext.xbase.Xbase.XUnaryOperation");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2079:3: this_XCastedExpression_3= ruleXCastedExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XCastedExpression_3=ruleXCastedExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XCastedExpression_3;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXUnaryOperation"
+
+
+ // $ANTLR start "entryRuleOpUnary"
+ // InternalOXtype.g:2091:1: entryRuleOpUnary returns [String current=null] : iv_ruleOpUnary= ruleOpUnary EOF ;
+ public final String entryRuleOpUnary() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleOpUnary = null;
+
+
+ try {
+ // InternalOXtype.g:2091:47: (iv_ruleOpUnary= ruleOpUnary EOF )
+ // InternalOXtype.g:2092:2: iv_ruleOpUnary= ruleOpUnary EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getOpUnaryRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleOpUnary=ruleOpUnary();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleOpUnary.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleOpUnary"
+
+
+ // $ANTLR start "ruleOpUnary"
+ // InternalOXtype.g:2098:1: ruleOpUnary returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '!' | kw= '-' | kw= '+' ) ;
+ public final AntlrDatatypeRuleToken ruleOpUnary() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token kw=null;
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:2104:2: ( (kw= '!' | kw= '-' | kw= '+' ) )
+ // InternalOXtype.g:2105:2: (kw= '!' | kw= '-' | kw= '+' )
+ {
+ // InternalOXtype.g:2105:2: (kw= '!' | kw= '-' | kw= '+' )
+ int alt36=3;
+ switch ( input.LA(1) ) {
+ case 53:
+ {
+ alt36=1;
+ }
+ break;
+ case 49:
+ {
+ alt36=2;
+ }
+ break;
+ case 48:
+ {
+ alt36=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 36, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt36) {
+ case 1 :
+ // InternalOXtype.g:2106:3: kw= '!'
+ {
+ kw=(Token)match(input,53,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2112:3: kw= '-'
+ {
+ kw=(Token)match(input,49,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1());
+
+ }
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:2118:3: kw= '+'
+ {
+ kw=(Token)match(input,48,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleOpUnary"
+
+
+ // $ANTLR start "entryRuleXCastedExpression"
+ // InternalOXtype.g:2127:1: entryRuleXCastedExpression returns [EObject current=null] : iv_ruleXCastedExpression= ruleXCastedExpression EOF ;
+ public final EObject entryRuleXCastedExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXCastedExpression = null;
+
+
+ try {
+ // InternalOXtype.g:2127:58: (iv_ruleXCastedExpression= ruleXCastedExpression EOF )
+ // InternalOXtype.g:2128:2: iv_ruleXCastedExpression= ruleXCastedExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXCastedExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXCastedExpression=ruleXCastedExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXCastedExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXCastedExpression"
+
+
+ // $ANTLR start "ruleXCastedExpression"
+ // InternalOXtype.g:2134:1: ruleXCastedExpression returns [EObject current=null] : (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* ) ;
+ public final EObject ruleXCastedExpression() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_2=null;
+ EObject this_XPostfixOperation_0 = null;
+
+ EObject lv_type_3_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:2140:2: ( (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* ) )
+ // InternalOXtype.g:2141:2: (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* )
+ {
+ // InternalOXtype.g:2141:2: (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* )
+ // InternalOXtype.g:2142:3: this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_33);
+ this_XPostfixOperation_0=ruleXPostfixOperation();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XPostfixOperation_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // InternalOXtype.g:2150:3: ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )*
+ loop37:
+ do {
+ int alt37=2;
+ int LA37_0 = input.LA(1);
+
+ if ( (LA37_0==54) ) {
+ int LA37_2 = input.LA(2);
+
+ if ( (synpred18_InternalOXtype()) ) {
+ alt37=1;
+ }
+
+
+ }
+
+
+ switch (alt37) {
+ case 1 :
+ // InternalOXtype.g:2151:4: ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) )
+ {
+ // InternalOXtype.g:2151:4: ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) )
+ // InternalOXtype.g:2152:5: ( ( () 'as' ) )=> ( () otherlv_2= 'as' )
+ {
+ // InternalOXtype.g:2158:5: ( () otherlv_2= 'as' )
+ // InternalOXtype.g:2159:6: () otherlv_2= 'as'
+ {
+ // InternalOXtype.g:2159:6: ()
+ // InternalOXtype.g:2160:7:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_2=(Token)match(input,54,FOLLOW_26); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1());
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:2172:4: ( (lv_type_3_0= ruleJvmTypeReference ) )
+ // InternalOXtype.g:2173:5: (lv_type_3_0= ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:2173:5: (lv_type_3_0= ruleJvmTypeReference )
+ // InternalOXtype.g:2174:6: lv_type_3_0= ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_33);
+ lv_type_3_0=ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXCastedExpressionRule());
+ }
+ set(
+ current,
+ "type",
+ lv_type_3_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop37;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXCastedExpression"
+
+
+ // $ANTLR start "entryRuleXPostfixOperation"
+ // InternalOXtype.g:2196:1: entryRuleXPostfixOperation returns [EObject current=null] : iv_ruleXPostfixOperation= ruleXPostfixOperation EOF ;
+ public final EObject entryRuleXPostfixOperation() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXPostfixOperation = null;
+
+
+ try {
+ // InternalOXtype.g:2196:58: (iv_ruleXPostfixOperation= ruleXPostfixOperation EOF )
+ // InternalOXtype.g:2197:2: iv_ruleXPostfixOperation= ruleXPostfixOperation EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXPostfixOperationRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXPostfixOperation=ruleXPostfixOperation();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXPostfixOperation;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXPostfixOperation"
+
+
+ // $ANTLR start "ruleXPostfixOperation"
+ // InternalOXtype.g:2203:1: ruleXPostfixOperation returns [EObject current=null] : (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? ) ;
+ public final EObject ruleXPostfixOperation() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_XMemberFeatureCall_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:2209:2: ( (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? ) )
+ // InternalOXtype.g:2210:2: (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? )
+ {
+ // InternalOXtype.g:2210:2: (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? )
+ // InternalOXtype.g:2211:3: this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )?
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_34);
+ this_XMemberFeatureCall_0=ruleXMemberFeatureCall();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XMemberFeatureCall_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // InternalOXtype.g:2219:3: ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )?
+ int alt38=2;
+ int LA38_0 = input.LA(1);
+
+ if ( (LA38_0==55) ) {
+ int LA38_1 = input.LA(2);
+
+ if ( (synpred19_InternalOXtype()) ) {
+ alt38=1;
+ }
+ }
+ else if ( (LA38_0==56) ) {
+ int LA38_2 = input.LA(2);
+
+ if ( (synpred19_InternalOXtype()) ) {
+ alt38=1;
+ }
+ }
+ switch (alt38) {
+ case 1 :
+ // InternalOXtype.g:2220:4: ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) )
+ {
+ // InternalOXtype.g:2230:4: ( () ( ( ruleOpPostfix ) ) )
+ // InternalOXtype.g:2231:5: () ( ( ruleOpPostfix ) )
+ {
+ // InternalOXtype.g:2231:5: ()
+ // InternalOXtype.g:2232:6:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:2238:5: ( ( ruleOpPostfix ) )
+ // InternalOXtype.g:2239:6: ( ruleOpPostfix )
+ {
+ // InternalOXtype.g:2239:6: ( ruleOpPostfix )
+ // InternalOXtype.g:2240:7: ruleOpPostfix
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXPostfixOperationRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ ruleOpPostfix();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXPostfixOperation"
+
+
+ // $ANTLR start "entryRuleOpPostfix"
+ // InternalOXtype.g:2260:1: entryRuleOpPostfix returns [String current=null] : iv_ruleOpPostfix= ruleOpPostfix EOF ;
+ public final String entryRuleOpPostfix() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleOpPostfix = null;
+
+
+ try {
+ // InternalOXtype.g:2260:49: (iv_ruleOpPostfix= ruleOpPostfix EOF )
+ // InternalOXtype.g:2261:2: iv_ruleOpPostfix= ruleOpPostfix EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getOpPostfixRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleOpPostfix=ruleOpPostfix();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleOpPostfix.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleOpPostfix"
+
+
+ // $ANTLR start "ruleOpPostfix"
+ // InternalOXtype.g:2267:1: ruleOpPostfix returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '++' | kw= '--' ) ;
+ public final AntlrDatatypeRuleToken ruleOpPostfix() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token kw=null;
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:2273:2: ( (kw= '++' | kw= '--' ) )
+ // InternalOXtype.g:2274:2: (kw= '++' | kw= '--' )
+ {
+ // InternalOXtype.g:2274:2: (kw= '++' | kw= '--' )
+ int alt39=2;
+ int LA39_0 = input.LA(1);
+
+ if ( (LA39_0==55) ) {
+ alt39=1;
+ }
+ else if ( (LA39_0==56) ) {
+ alt39=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 39, 0, input);
+
+ throw nvae;
+ }
+ switch (alt39) {
+ case 1 :
+ // InternalOXtype.g:2275:3: kw= '++'
+ {
+ kw=(Token)match(input,55,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2281:3: kw= '--'
+ {
+ kw=(Token)match(input,56,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleOpPostfix"
+
+
+ // $ANTLR start "entryRuleXMemberFeatureCall"
+ // InternalOXtype.g:2290:1: entryRuleXMemberFeatureCall returns [EObject current=null] : iv_ruleXMemberFeatureCall= ruleXMemberFeatureCall EOF ;
+ public final EObject entryRuleXMemberFeatureCall() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXMemberFeatureCall = null;
+
+
+ try {
+ // InternalOXtype.g:2290:59: (iv_ruleXMemberFeatureCall= ruleXMemberFeatureCall EOF )
+ // InternalOXtype.g:2291:2: iv_ruleXMemberFeatureCall= ruleXMemberFeatureCall EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXMemberFeatureCall=ruleXMemberFeatureCall();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXMemberFeatureCall;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXMemberFeatureCall"
+
+
+ // $ANTLR start "ruleXMemberFeatureCall"
+ // InternalOXtype.g:2297:1: ruleXMemberFeatureCall returns [EObject current=null] : (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* ) ;
+ public final EObject ruleXMemberFeatureCall() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_2=null;
+ Token lv_explicitStatic_3_0=null;
+ Token otherlv_8=null;
+ Token lv_nullSafe_9_0=null;
+ Token lv_explicitStatic_10_0=null;
+ Token otherlv_11=null;
+ Token otherlv_13=null;
+ Token otherlv_15=null;
+ Token lv_explicitOperationCall_17_0=null;
+ Token otherlv_20=null;
+ Token otherlv_22=null;
+ EObject this_XPrimaryExpression_0 = null;
+
+ EObject lv_value_6_0 = null;
+
+ EObject lv_typeArguments_12_0 = null;
+
+ EObject lv_typeArguments_14_0 = null;
+
+ EObject lv_memberCallArguments_18_0 = null;
+
+ EObject lv_memberCallArguments_19_0 = null;
+
+ EObject lv_memberCallArguments_21_0 = null;
+
+ EObject lv_memberCallArguments_23_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:2303:2: ( (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* ) )
+ // InternalOXtype.g:2304:2: (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* )
+ {
+ // InternalOXtype.g:2304:2: (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* )
+ // InternalOXtype.g:2305:3: this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_35);
+ this_XPrimaryExpression_0=ruleXPrimaryExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XPrimaryExpression_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // InternalOXtype.g:2313:3: ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )*
+ loop48:
+ do {
+ int alt48=3;
+ switch ( input.LA(1) ) {
+ case 57:
+ {
+ int LA48_2 = input.LA(2);
+
+ if ( (synpred20_InternalOXtype()) ) {
+ alt48=1;
+ }
+ else if ( (synpred21_InternalOXtype()) ) {
+ alt48=2;
+ }
+
+
+ }
+ break;
+ case 58:
+ {
+ int LA48_3 = input.LA(2);
+
+ if ( (synpred20_InternalOXtype()) ) {
+ alt48=1;
+ }
+ else if ( (synpred21_InternalOXtype()) ) {
+ alt48=2;
+ }
+
+
+ }
+ break;
+ case 59:
+ {
+ int LA48_4 = input.LA(2);
+
+ if ( (synpred21_InternalOXtype()) ) {
+ alt48=2;
+ }
+
+
+ }
+ break;
+
+ }
+
+ switch (alt48) {
+ case 1 :
+ // InternalOXtype.g:2314:4: ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) )
+ {
+ // InternalOXtype.g:2314:4: ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) )
+ // InternalOXtype.g:2315:5: ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) )
+ {
+ // InternalOXtype.g:2315:5: ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )
+ // InternalOXtype.g:2316:6: ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign )
+ {
+ // InternalOXtype.g:2336:6: ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign )
+ // InternalOXtype.g:2337:7: () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign
+ {
+ // InternalOXtype.g:2337:7: ()
+ // InternalOXtype.g:2338:8:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:2344:7: (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) )
+ int alt40=2;
+ int LA40_0 = input.LA(1);
+
+ if ( (LA40_0==57) ) {
+ alt40=1;
+ }
+ else if ( (LA40_0==58) ) {
+ alt40=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 40, 0, input);
+
+ throw nvae;
+ }
+ switch (alt40) {
+ case 1 :
+ // InternalOXtype.g:2345:8: otherlv_2= '.'
+ {
+ otherlv_2=(Token)match(input,57,FOLLOW_36); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2350:8: ( (lv_explicitStatic_3_0= '::' ) )
+ {
+ // InternalOXtype.g:2350:8: ( (lv_explicitStatic_3_0= '::' ) )
+ // InternalOXtype.g:2351:9: (lv_explicitStatic_3_0= '::' )
+ {
+ // InternalOXtype.g:2351:9: (lv_explicitStatic_3_0= '::' )
+ // InternalOXtype.g:2352:10: lv_explicitStatic_3_0= '::'
+ {
+ lv_explicitStatic_3_0=(Token)match(input,58,FOLLOW_36); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_explicitStatic_3_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+ setWithLastConsumed(current, "explicitStatic", true, "::");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:2365:7: ( ( ruleFeatureCallID ) )
+ // InternalOXtype.g:2366:8: ( ruleFeatureCallID )
+ {
+ // InternalOXtype.g:2366:8: ( ruleFeatureCallID )
+ // InternalOXtype.g:2367:9: ruleFeatureCallID
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0());
+
+ }
+ pushFollow(FOLLOW_12);
+ ruleFeatureCallID();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3());
+
+ }
+ pushFollow(FOLLOW_13);
+ ruleOpSingleAssign();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:2390:5: ( (lv_value_6_0= ruleXAssignment ) )
+ // InternalOXtype.g:2391:6: (lv_value_6_0= ruleXAssignment )
+ {
+ // InternalOXtype.g:2391:6: (lv_value_6_0= ruleXAssignment )
+ // InternalOXtype.g:2392:7: lv_value_6_0= ruleXAssignment
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0());
+
+ }
+ pushFollow(FOLLOW_35);
+ lv_value_6_0=ruleXAssignment();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ set(
+ current,
+ "value",
+ lv_value_6_0,
+ "org.eclipse.xtext.xbase.Xbase.XAssignment");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2411:4: ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? )
+ {
+ // InternalOXtype.g:2411:4: ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? )
+ // InternalOXtype.g:2412:5: ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )?
+ {
+ // InternalOXtype.g:2412:5: ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) )
+ // InternalOXtype.g:2413:6: ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) )
+ {
+ // InternalOXtype.g:2433:6: ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) )
+ // InternalOXtype.g:2434:7: () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) )
+ {
+ // InternalOXtype.g:2434:7: ()
+ // InternalOXtype.g:2435:8:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:2441:7: (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) )
+ int alt41=3;
+ switch ( input.LA(1) ) {
+ case 57:
+ {
+ alt41=1;
+ }
+ break;
+ case 59:
+ {
+ alt41=2;
+ }
+ break;
+ case 58:
+ {
+ alt41=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 41, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt41) {
+ case 1 :
+ // InternalOXtype.g:2442:8: otherlv_8= '.'
+ {
+ otherlv_8=(Token)match(input,57,FOLLOW_37); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_8, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2447:8: ( (lv_nullSafe_9_0= '?.' ) )
+ {
+ // InternalOXtype.g:2447:8: ( (lv_nullSafe_9_0= '?.' ) )
+ // InternalOXtype.g:2448:9: (lv_nullSafe_9_0= '?.' )
+ {
+ // InternalOXtype.g:2448:9: (lv_nullSafe_9_0= '?.' )
+ // InternalOXtype.g:2449:10: lv_nullSafe_9_0= '?.'
+ {
+ lv_nullSafe_9_0=(Token)match(input,59,FOLLOW_37); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_nullSafe_9_0, grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+ setWithLastConsumed(current, "nullSafe", true, "?.");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:2462:8: ( (lv_explicitStatic_10_0= '::' ) )
+ {
+ // InternalOXtype.g:2462:8: ( (lv_explicitStatic_10_0= '::' ) )
+ // InternalOXtype.g:2463:9: (lv_explicitStatic_10_0= '::' )
+ {
+ // InternalOXtype.g:2463:9: (lv_explicitStatic_10_0= '::' )
+ // InternalOXtype.g:2464:10: lv_explicitStatic_10_0= '::'
+ {
+ lv_explicitStatic_10_0=(Token)match(input,58,FOLLOW_37); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_explicitStatic_10_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+ setWithLastConsumed(current, "explicitStatic", true, "::");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:2479:5: (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )?
+ int alt43=2;
+ int LA43_0 = input.LA(1);
+
+ if ( (LA43_0==32) ) {
+ alt43=1;
+ }
+ switch (alt43) {
+ case 1 :
+ // InternalOXtype.g:2480:6: otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>'
+ {
+ otherlv_11=(Token)match(input,32,FOLLOW_38); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_11, grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0());
+
+ }
+ // InternalOXtype.g:2484:6: ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:2485:7: (lv_typeArguments_12_0= ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:2485:7: (lv_typeArguments_12_0= ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:2486:8: lv_typeArguments_12_0= ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_39);
+ lv_typeArguments_12_0=ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ current,
+ "typeArguments",
+ lv_typeArguments_12_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:2503:6: (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )*
+ loop42:
+ do {
+ int alt42=2;
+ int LA42_0 = input.LA(1);
+
+ if ( (LA42_0==21) ) {
+ alt42=1;
+ }
+
+
+ switch (alt42) {
+ case 1 :
+ // InternalOXtype.g:2504:7: otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) )
+ {
+ otherlv_13=(Token)match(input,21,FOLLOW_38); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_13, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0());
+
+ }
+ // InternalOXtype.g:2508:7: ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:2509:8: (lv_typeArguments_14_0= ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:2509:8: (lv_typeArguments_14_0= ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:2510:9: lv_typeArguments_14_0= ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0());
+
+ }
+ pushFollow(FOLLOW_39);
+ lv_typeArguments_14_0=ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ current,
+ "typeArguments",
+ lv_typeArguments_14_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop42;
+ }
+ } while (true);
+
+ otherlv_15=(Token)match(input,33,FOLLOW_37); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_15, grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3());
+
+ }
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:2533:5: ( ( ruleIdOrSuper ) )
+ // InternalOXtype.g:2534:6: ( ruleIdOrSuper )
+ {
+ // InternalOXtype.g:2534:6: ( ruleIdOrSuper )
+ // InternalOXtype.g:2535:7: ruleIdOrSuper
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0());
+
+ }
+ pushFollow(FOLLOW_40);
+ ruleIdOrSuper();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:2549:5: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )?
+ int alt46=2;
+ alt46 = dfa46.predict(input);
+ switch (alt46) {
+ case 1 :
+ // InternalOXtype.g:2550:6: ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')'
+ {
+ // InternalOXtype.g:2550:6: ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) )
+ // InternalOXtype.g:2551:7: ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' )
+ {
+ // InternalOXtype.g:2555:7: (lv_explicitOperationCall_17_0= '(' )
+ // InternalOXtype.g:2556:8: lv_explicitOperationCall_17_0= '('
+ {
+ lv_explicitOperationCall_17_0=(Token)match(input,20,FOLLOW_41); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_explicitOperationCall_17_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+ setWithLastConsumed(current, "explicitOperationCall", true, "(");
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:2568:6: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )?
+ int alt45=3;
+ alt45 = dfa45.predict(input);
+ switch (alt45) {
+ case 1 :
+ // InternalOXtype.g:2569:7: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) )
+ {
+ // InternalOXtype.g:2569:7: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) )
+ // InternalOXtype.g:2570:8: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure )
+ {
+ // InternalOXtype.g:2595:8: (lv_memberCallArguments_18_0= ruleXShortClosure )
+ // InternalOXtype.g:2596:9: lv_memberCallArguments_18_0= ruleXShortClosure
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0());
+
+ }
+ pushFollow(FOLLOW_11);
+ lv_memberCallArguments_18_0=ruleXShortClosure();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ current,
+ "memberCallArguments",
+ lv_memberCallArguments_18_0,
+ "org.eclipse.xtext.xbase.Xbase.XShortClosure");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2614:7: ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* )
+ {
+ // InternalOXtype.g:2614:7: ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* )
+ // InternalOXtype.g:2615:8: ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )*
+ {
+ // InternalOXtype.g:2615:8: ( (lv_memberCallArguments_19_0= ruleXExpression ) )
+ // InternalOXtype.g:2616:9: (lv_memberCallArguments_19_0= ruleXExpression )
+ {
+ // InternalOXtype.g:2616:9: (lv_memberCallArguments_19_0= ruleXExpression )
+ // InternalOXtype.g:2617:10: lv_memberCallArguments_19_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0());
+
+ }
+ pushFollow(FOLLOW_10);
+ lv_memberCallArguments_19_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ current,
+ "memberCallArguments",
+ lv_memberCallArguments_19_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:2634:8: (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )*
+ loop44:
+ do {
+ int alt44=2;
+ int LA44_0 = input.LA(1);
+
+ if ( (LA44_0==21) ) {
+ alt44=1;
+ }
+
+
+ switch (alt44) {
+ case 1 :
+ // InternalOXtype.g:2635:9: otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) )
+ {
+ otherlv_20=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_20, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0());
+
+ }
+ // InternalOXtype.g:2639:9: ( (lv_memberCallArguments_21_0= ruleXExpression ) )
+ // InternalOXtype.g:2640:10: (lv_memberCallArguments_21_0= ruleXExpression )
+ {
+ // InternalOXtype.g:2640:10: (lv_memberCallArguments_21_0= ruleXExpression )
+ // InternalOXtype.g:2641:11: lv_memberCallArguments_21_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_10);
+ lv_memberCallArguments_21_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ current,
+ "memberCallArguments",
+ lv_memberCallArguments_21_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop44;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ otherlv_22=(Token)match(input,22,FOLLOW_42); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_22, grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:2666:5: ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )?
+ int alt47=2;
+ alt47 = dfa47.predict(input);
+ switch (alt47) {
+ case 1 :
+ // InternalOXtype.g:2667:6: ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure )
+ {
+ // InternalOXtype.g:2673:6: (lv_memberCallArguments_23_0= ruleXClosure )
+ // InternalOXtype.g:2674:7: lv_memberCallArguments_23_0= ruleXClosure
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0());
+
+ }
+ pushFollow(FOLLOW_35);
+ lv_memberCallArguments_23_0=ruleXClosure();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ current,
+ "memberCallArguments",
+ lv_memberCallArguments_23_0,
+ "org.eclipse.xtext.xbase.Xbase.XClosure");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop48;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXMemberFeatureCall"
+
+
+ // $ANTLR start "entryRuleXPrimaryExpression"
+ // InternalOXtype.g:2697:1: entryRuleXPrimaryExpression returns [EObject current=null] : iv_ruleXPrimaryExpression= ruleXPrimaryExpression EOF ;
+ public final EObject entryRuleXPrimaryExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXPrimaryExpression = null;
+
+
+ try {
+ // InternalOXtype.g:2697:59: (iv_ruleXPrimaryExpression= ruleXPrimaryExpression EOF )
+ // InternalOXtype.g:2698:2: iv_ruleXPrimaryExpression= ruleXPrimaryExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXPrimaryExpression=ruleXPrimaryExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXPrimaryExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXPrimaryExpression"
+
+
+ // $ANTLR start "ruleXPrimaryExpression"
+ // InternalOXtype.g:2704:1: ruleXPrimaryExpression returns [EObject current=null] : (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression ) ;
+ public final EObject ruleXPrimaryExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_XConstructorCall_0 = null;
+
+ EObject this_XBlockExpression_1 = null;
+
+ EObject this_XSwitchExpression_2 = null;
+
+ EObject this_XSynchronizedExpression_3 = null;
+
+ EObject this_XFeatureCall_4 = null;
+
+ EObject this_XLiteral_5 = null;
+
+ EObject this_XIfExpression_6 = null;
+
+ EObject this_XForLoopExpression_7 = null;
+
+ EObject this_XBasicForLoopExpression_8 = null;
+
+ EObject this_XWhileExpression_9 = null;
+
+ EObject this_XDoWhileExpression_10 = null;
+
+ EObject this_XThrowExpression_11 = null;
+
+ EObject this_XReturnExpression_12 = null;
+
+ EObject this_XTryCatchFinallyExpression_13 = null;
+
+ EObject this_XParenthesizedExpression_14 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:2710:2: ( (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression ) )
+ // InternalOXtype.g:2711:2: (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression )
+ {
+ // InternalOXtype.g:2711:2: (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression )
+ int alt49=15;
+ alt49 = dfa49.predict(input);
+ switch (alt49) {
+ case 1 :
+ // InternalOXtype.g:2712:3: this_XConstructorCall_0= ruleXConstructorCall
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XConstructorCall_0=ruleXConstructorCall();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XConstructorCall_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2721:3: this_XBlockExpression_1= ruleXBlockExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XBlockExpression_1=ruleXBlockExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XBlockExpression_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:2730:3: this_XSwitchExpression_2= ruleXSwitchExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XSwitchExpression_2=ruleXSwitchExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XSwitchExpression_2;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:2739:3: ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression )
+ {
+ // InternalOXtype.g:2739:3: ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression )
+ // InternalOXtype.g:2740:4: ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XSynchronizedExpression_3=ruleXSynchronizedExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XSynchronizedExpression_3;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 5 :
+ // InternalOXtype.g:2757:3: this_XFeatureCall_4= ruleXFeatureCall
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XFeatureCall_4=ruleXFeatureCall();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XFeatureCall_4;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 6 :
+ // InternalOXtype.g:2766:3: this_XLiteral_5= ruleXLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XLiteral_5=ruleXLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XLiteral_5;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 7 :
+ // InternalOXtype.g:2775:3: this_XIfExpression_6= ruleXIfExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XIfExpression_6=ruleXIfExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XIfExpression_6;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 8 :
+ // InternalOXtype.g:2784:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression )
+ {
+ // InternalOXtype.g:2784:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression )
+ // InternalOXtype.g:2785:4: ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XForLoopExpression_7=ruleXForLoopExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XForLoopExpression_7;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 9 :
+ // InternalOXtype.g:2808:3: this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XBasicForLoopExpression_8=ruleXBasicForLoopExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XBasicForLoopExpression_8;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 10 :
+ // InternalOXtype.g:2817:3: this_XWhileExpression_9= ruleXWhileExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XWhileExpression_9=ruleXWhileExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XWhileExpression_9;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 11 :
+ // InternalOXtype.g:2826:3: this_XDoWhileExpression_10= ruleXDoWhileExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XDoWhileExpression_10=ruleXDoWhileExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XDoWhileExpression_10;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 12 :
+ // InternalOXtype.g:2835:3: this_XThrowExpression_11= ruleXThrowExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XThrowExpression_11=ruleXThrowExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XThrowExpression_11;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 13 :
+ // InternalOXtype.g:2844:3: this_XReturnExpression_12= ruleXReturnExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XReturnExpression_12=ruleXReturnExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XReturnExpression_12;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 14 :
+ // InternalOXtype.g:2853:3: this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XTryCatchFinallyExpression_13=ruleXTryCatchFinallyExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XTryCatchFinallyExpression_13;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 15 :
+ // InternalOXtype.g:2862:3: this_XParenthesizedExpression_14= ruleXParenthesizedExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XParenthesizedExpression_14=ruleXParenthesizedExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XParenthesizedExpression_14;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXPrimaryExpression"
+
+
+ // $ANTLR start "entryRuleXLiteral"
+ // InternalOXtype.g:2874:1: entryRuleXLiteral returns [EObject current=null] : iv_ruleXLiteral= ruleXLiteral EOF ;
+ public final EObject entryRuleXLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXLiteral = null;
+
+
+ try {
+ // InternalOXtype.g:2874:49: (iv_ruleXLiteral= ruleXLiteral EOF )
+ // InternalOXtype.g:2875:2: iv_ruleXLiteral= ruleXLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXLiteral=ruleXLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXLiteral;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXLiteral"
+
+
+ // $ANTLR start "ruleXLiteral"
+ // InternalOXtype.g:2881:1: ruleXLiteral returns [EObject current=null] : (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral ) ;
+ public final EObject ruleXLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_XCollectionLiteral_0 = null;
+
+ EObject this_XClosure_1 = null;
+
+ EObject this_XBooleanLiteral_2 = null;
+
+ EObject this_XNumberLiteral_3 = null;
+
+ EObject this_XNullLiteral_4 = null;
+
+ EObject this_XStringLiteral_5 = null;
+
+ EObject this_XTypeLiteral_6 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:2887:2: ( (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral ) )
+ // InternalOXtype.g:2888:2: (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral )
+ {
+ // InternalOXtype.g:2888:2: (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral )
+ int alt50=7;
+ int LA50_0 = input.LA(1);
+
+ if ( (LA50_0==24) ) {
+ alt50=1;
+ }
+ else if ( (LA50_0==25) && (synpred27_InternalOXtype())) {
+ alt50=2;
+ }
+ else if ( ((LA50_0>=77 && LA50_0<=78)) ) {
+ alt50=3;
+ }
+ else if ( ((LA50_0>=RULE_HEX && LA50_0<=RULE_DECIMAL)) ) {
+ alt50=4;
+ }
+ else if ( (LA50_0==79) ) {
+ alt50=5;
+ }
+ else if ( (LA50_0==RULE_STRING) ) {
+ alt50=6;
+ }
+ else if ( (LA50_0==80) ) {
+ alt50=7;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 50, 0, input);
+
+ throw nvae;
+ }
+ switch (alt50) {
+ case 1 :
+ // InternalOXtype.g:2889:3: this_XCollectionLiteral_0= ruleXCollectionLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XCollectionLiteral_0=ruleXCollectionLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XCollectionLiteral_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2898:3: ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure )
+ {
+ // InternalOXtype.g:2898:3: ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure )
+ // InternalOXtype.g:2899:4: ( ( () '[' ) )=>this_XClosure_1= ruleXClosure
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XClosure_1=ruleXClosure();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XClosure_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:2915:3: this_XBooleanLiteral_2= ruleXBooleanLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XBooleanLiteral_2=ruleXBooleanLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XBooleanLiteral_2;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:2924:3: this_XNumberLiteral_3= ruleXNumberLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XNumberLiteral_3=ruleXNumberLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XNumberLiteral_3;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 5 :
+ // InternalOXtype.g:2933:3: this_XNullLiteral_4= ruleXNullLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XNullLiteral_4=ruleXNullLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XNullLiteral_4;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 6 :
+ // InternalOXtype.g:2942:3: this_XStringLiteral_5= ruleXStringLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XStringLiteral_5=ruleXStringLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XStringLiteral_5;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 7 :
+ // InternalOXtype.g:2951:3: this_XTypeLiteral_6= ruleXTypeLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XTypeLiteral_6=ruleXTypeLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XTypeLiteral_6;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXLiteral"
+
+
+ // $ANTLR start "entryRuleXCollectionLiteral"
+ // InternalOXtype.g:2963:1: entryRuleXCollectionLiteral returns [EObject current=null] : iv_ruleXCollectionLiteral= ruleXCollectionLiteral EOF ;
+ public final EObject entryRuleXCollectionLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXCollectionLiteral = null;
+
+
+ try {
+ // InternalOXtype.g:2963:59: (iv_ruleXCollectionLiteral= ruleXCollectionLiteral EOF )
+ // InternalOXtype.g:2964:2: iv_ruleXCollectionLiteral= ruleXCollectionLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXCollectionLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXCollectionLiteral=ruleXCollectionLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXCollectionLiteral;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXCollectionLiteral"
+
+
+ // $ANTLR start "ruleXCollectionLiteral"
+ // InternalOXtype.g:2970:1: ruleXCollectionLiteral returns [EObject current=null] : (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral ) ;
+ public final EObject ruleXCollectionLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_XSetLiteral_0 = null;
+
+ EObject this_XListLiteral_1 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:2976:2: ( (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral ) )
+ // InternalOXtype.g:2977:2: (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral )
+ {
+ // InternalOXtype.g:2977:2: (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral )
+ int alt51=2;
+ int LA51_0 = input.LA(1);
+
+ if ( (LA51_0==24) ) {
+ int LA51_1 = input.LA(2);
+
+ if ( (LA51_1==60) ) {
+ alt51=1;
+ }
+ else if ( (LA51_1==25) ) {
+ alt51=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 51, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 51, 0, input);
+
+ throw nvae;
+ }
+ switch (alt51) {
+ case 1 :
+ // InternalOXtype.g:2978:3: this_XSetLiteral_0= ruleXSetLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XSetLiteral_0=ruleXSetLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XSetLiteral_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2987:3: this_XListLiteral_1= ruleXListLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XListLiteral_1=ruleXListLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XListLiteral_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXCollectionLiteral"
+
+
+ // $ANTLR start "entryRuleXSetLiteral"
+ // InternalOXtype.g:2999:1: entryRuleXSetLiteral returns [EObject current=null] : iv_ruleXSetLiteral= ruleXSetLiteral EOF ;
+ public final EObject entryRuleXSetLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXSetLiteral = null;
+
+
+ try {
+ // InternalOXtype.g:2999:52: (iv_ruleXSetLiteral= ruleXSetLiteral EOF )
+ // InternalOXtype.g:3000:2: iv_ruleXSetLiteral= ruleXSetLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXSetLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXSetLiteral=ruleXSetLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXSetLiteral;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXSetLiteral"
+
+
+ // $ANTLR start "ruleXSetLiteral"
+ // InternalOXtype.g:3006:1: ruleXSetLiteral returns [EObject current=null] : ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' ) ;
+ public final EObject ruleXSetLiteral() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_2=null;
+ Token otherlv_4=null;
+ Token otherlv_6=null;
+ EObject lv_elements_3_0 = null;
+
+ EObject lv_elements_5_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:3012:2: ( ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' ) )
+ // InternalOXtype.g:3013:2: ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' )
+ {
+ // InternalOXtype.g:3013:2: ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' )
+ // InternalOXtype.g:3014:3: () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}'
+ {
+ // InternalOXtype.g:3014:3: ()
+ // InternalOXtype.g:3015:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,24,FOLLOW_43); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1());
+
+ }
+ otherlv_2=(Token)match(input,60,FOLLOW_44); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2());
+
+ }
+ // InternalOXtype.g:3029:3: ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )?
+ int alt53=2;
+ int LA53_0 = input.LA(1);
+
+ if ( ((LA53_0>=RULE_STRING && LA53_0<=RULE_ID)||(LA53_0>=13 && LA53_0<=15)||LA53_0==20||(LA53_0>=24 && LA53_0<=25)||LA53_0==32||(LA53_0>=48 && LA53_0<=49)||LA53_0==53||LA53_0==60||LA53_0==63||LA53_0==65||(LA53_0>=69 && LA53_0<=71)||(LA53_0>=74 && LA53_0<=83)||LA53_0==85) ) {
+ alt53=1;
+ }
+ switch (alt53) {
+ case 1 :
+ // InternalOXtype.g:3030:4: ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )*
+ {
+ // InternalOXtype.g:3030:4: ( (lv_elements_3_0= ruleXExpression ) )
+ // InternalOXtype.g:3031:5: (lv_elements_3_0= ruleXExpression )
+ {
+ // InternalOXtype.g:3031:5: (lv_elements_3_0= ruleXExpression )
+ // InternalOXtype.g:3032:6: lv_elements_3_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0());
+
+ }
+ pushFollow(FOLLOW_45);
+ lv_elements_3_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXSetLiteralRule());
+ }
+ add(
+ current,
+ "elements",
+ lv_elements_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:3049:4: (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )*
+ loop52:
+ do {
+ int alt52=2;
+ int LA52_0 = input.LA(1);
+
+ if ( (LA52_0==21) ) {
+ alt52=1;
+ }
+
+
+ switch (alt52) {
+ case 1 :
+ // InternalOXtype.g:3050:5: otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) )
+ {
+ otherlv_4=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_4, grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0());
+
+ }
+ // InternalOXtype.g:3054:5: ( (lv_elements_5_0= ruleXExpression ) )
+ // InternalOXtype.g:3055:6: (lv_elements_5_0= ruleXExpression )
+ {
+ // InternalOXtype.g:3055:6: (lv_elements_5_0= ruleXExpression )
+ // InternalOXtype.g:3056:7: lv_elements_5_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0());
+
+ }
+ pushFollow(FOLLOW_45);
+ lv_elements_5_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXSetLiteralRule());
+ }
+ add(
+ current,
+ "elements",
+ lv_elements_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop52;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ otherlv_6=(Token)match(input,61,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_6, grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXSetLiteral"
+
+
+ // $ANTLR start "entryRuleXListLiteral"
+ // InternalOXtype.g:3083:1: entryRuleXListLiteral returns [EObject current=null] : iv_ruleXListLiteral= ruleXListLiteral EOF ;
+ public final EObject entryRuleXListLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXListLiteral = null;
+
+
+ try {
+ // InternalOXtype.g:3083:53: (iv_ruleXListLiteral= ruleXListLiteral EOF )
+ // InternalOXtype.g:3084:2: iv_ruleXListLiteral= ruleXListLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXListLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXListLiteral=ruleXListLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXListLiteral;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXListLiteral"
+
+
+ // $ANTLR start "ruleXListLiteral"
+ // InternalOXtype.g:3090:1: ruleXListLiteral returns [EObject current=null] : ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' ) ;
+ public final EObject ruleXListLiteral() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_2=null;
+ Token otherlv_4=null;
+ Token otherlv_6=null;
+ EObject lv_elements_3_0 = null;
+
+ EObject lv_elements_5_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:3096:2: ( ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' ) )
+ // InternalOXtype.g:3097:2: ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' )
+ {
+ // InternalOXtype.g:3097:2: ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' )
+ // InternalOXtype.g:3098:3: () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']'
+ {
+ // InternalOXtype.g:3098:3: ()
+ // InternalOXtype.g:3099:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXListLiteralAccess().getXListLiteralAction_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,24,FOLLOW_14); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1());
+
+ }
+ otherlv_2=(Token)match(input,25,FOLLOW_15); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2());
+
+ }
+ // InternalOXtype.g:3113:3: ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )?
+ int alt55=2;
+ int LA55_0 = input.LA(1);
+
+ if ( ((LA55_0>=RULE_STRING && LA55_0<=RULE_ID)||(LA55_0>=13 && LA55_0<=15)||LA55_0==20||(LA55_0>=24 && LA55_0<=25)||LA55_0==32||(LA55_0>=48 && LA55_0<=49)||LA55_0==53||LA55_0==60||LA55_0==63||LA55_0==65||(LA55_0>=69 && LA55_0<=71)||(LA55_0>=74 && LA55_0<=83)||LA55_0==85) ) {
+ alt55=1;
+ }
+ switch (alt55) {
+ case 1 :
+ // InternalOXtype.g:3114:4: ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )*
+ {
+ // InternalOXtype.g:3114:4: ( (lv_elements_3_0= ruleXExpression ) )
+ // InternalOXtype.g:3115:5: (lv_elements_3_0= ruleXExpression )
+ {
+ // InternalOXtype.g:3115:5: (lv_elements_3_0= ruleXExpression )
+ // InternalOXtype.g:3116:6: lv_elements_3_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0());
+
+ }
+ pushFollow(FOLLOW_16);
+ lv_elements_3_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXListLiteralRule());
+ }
+ add(
+ current,
+ "elements",
+ lv_elements_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:3133:4: (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )*
+ loop54:
+ do {
+ int alt54=2;
+ int LA54_0 = input.LA(1);
+
+ if ( (LA54_0==21) ) {
+ alt54=1;
+ }
+
+
+ switch (alt54) {
+ case 1 :
+ // InternalOXtype.g:3134:5: otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) )
+ {
+ otherlv_4=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_4, grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0());
+
+ }
+ // InternalOXtype.g:3138:5: ( (lv_elements_5_0= ruleXExpression ) )
+ // InternalOXtype.g:3139:6: (lv_elements_5_0= ruleXExpression )
+ {
+ // InternalOXtype.g:3139:6: (lv_elements_5_0= ruleXExpression )
+ // InternalOXtype.g:3140:7: lv_elements_5_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0());
+
+ }
+ pushFollow(FOLLOW_16);
+ lv_elements_5_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXListLiteralRule());
+ }
+ add(
+ current,
+ "elements",
+ lv_elements_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop54;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ otherlv_6=(Token)match(input,26,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_6, grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXListLiteral"
+
+
+ // $ANTLR start "entryRuleXClosure"
+ // InternalOXtype.g:3167:1: entryRuleXClosure returns [EObject current=null] : iv_ruleXClosure= ruleXClosure EOF ;
+ public final EObject entryRuleXClosure() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXClosure = null;
+
+
+ try {
+ // InternalOXtype.g:3167:49: (iv_ruleXClosure= ruleXClosure EOF )
+ // InternalOXtype.g:3168:2: iv_ruleXClosure= ruleXClosure EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXClosureRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXClosure=ruleXClosure();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXClosure;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXClosure"
+
+
+ // $ANTLR start "ruleXClosure"
+ // InternalOXtype.g:3174:1: ruleXClosure returns [EObject current=null] : ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' ) ;
+ public final EObject ruleXClosure() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_3=null;
+ Token lv_explicitSyntax_5_0=null;
+ Token otherlv_7=null;
+ EObject lv_declaredFormalParameters_2_0 = null;
+
+ EObject lv_declaredFormalParameters_4_0 = null;
+
+ EObject lv_expression_6_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:3180:2: ( ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' ) )
+ // InternalOXtype.g:3181:2: ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' )
+ {
+ // InternalOXtype.g:3181:2: ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' )
+ // InternalOXtype.g:3182:3: ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']'
+ {
+ // InternalOXtype.g:3182:3: ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) )
+ // InternalOXtype.g:3183:4: ( ( () '[' ) )=> ( () otherlv_1= '[' )
+ {
+ // InternalOXtype.g:3189:4: ( () otherlv_1= '[' )
+ // InternalOXtype.g:3190:5: () otherlv_1= '['
+ {
+ // InternalOXtype.g:3190:5: ()
+ // InternalOXtype.g:3191:6:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXClosureAccess().getXClosureAction_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,25,FOLLOW_46); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1());
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:3203:3: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )?
+ int alt58=2;
+ alt58 = dfa58.predict(input);
+ switch (alt58) {
+ case 1 :
+ // InternalOXtype.g:3204:4: ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) )
+ {
+ // InternalOXtype.g:3227:4: ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) )
+ // InternalOXtype.g:3228:5: ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) )
+ {
+ // InternalOXtype.g:3228:5: ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )?
+ int alt57=2;
+ int LA57_0 = input.LA(1);
+
+ if ( (LA57_0==RULE_ID||LA57_0==20||LA57_0==45) ) {
+ alt57=1;
+ }
+ switch (alt57) {
+ case 1 :
+ // InternalOXtype.g:3229:6: ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )*
+ {
+ // InternalOXtype.g:3229:6: ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) )
+ // InternalOXtype.g:3230:7: (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:3230:7: (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter )
+ // InternalOXtype.g:3231:8: lv_declaredFormalParameters_2_0= ruleJvmFormalParameter
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0());
+
+ }
+ pushFollow(FOLLOW_47);
+ lv_declaredFormalParameters_2_0=ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXClosureRule());
+ }
+ add(
+ current,
+ "declaredFormalParameters",
+ lv_declaredFormalParameters_2_0,
+ "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:3248:6: (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )*
+ loop56:
+ do {
+ int alt56=2;
+ int LA56_0 = input.LA(1);
+
+ if ( (LA56_0==21) ) {
+ alt56=1;
+ }
+
+
+ switch (alt56) {
+ case 1 :
+ // InternalOXtype.g:3249:7: otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) )
+ {
+ otherlv_3=(Token)match(input,21,FOLLOW_26); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_3, grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0());
+
+ }
+ // InternalOXtype.g:3253:7: ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) )
+ // InternalOXtype.g:3254:8: (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:3254:8: (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter )
+ // InternalOXtype.g:3255:9: lv_declaredFormalParameters_4_0= ruleJvmFormalParameter
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0());
+
+ }
+ pushFollow(FOLLOW_47);
+ lv_declaredFormalParameters_4_0=ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXClosureRule());
+ }
+ add(
+ current,
+ "declaredFormalParameters",
+ lv_declaredFormalParameters_4_0,
+ "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop56;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:3274:5: ( (lv_explicitSyntax_5_0= '|' ) )
+ // InternalOXtype.g:3275:6: (lv_explicitSyntax_5_0= '|' )
+ {
+ // InternalOXtype.g:3275:6: (lv_explicitSyntax_5_0= '|' )
+ // InternalOXtype.g:3276:7: lv_explicitSyntax_5_0= '|'
+ {
+ lv_explicitSyntax_5_0=(Token)match(input,62,FOLLOW_48); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_explicitSyntax_5_0, grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXClosureRule());
+ }
+ setWithLastConsumed(current, "explicitSyntax", true, "|");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:3290:3: ( (lv_expression_6_0= ruleXExpressionInClosure ) )
+ // InternalOXtype.g:3291:4: (lv_expression_6_0= ruleXExpressionInClosure )
+ {
+ // InternalOXtype.g:3291:4: (lv_expression_6_0= ruleXExpressionInClosure )
+ // InternalOXtype.g:3292:5: lv_expression_6_0= ruleXExpressionInClosure
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_49);
+ lv_expression_6_0=ruleXExpressionInClosure();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXClosureRule());
+ }
+ set(
+ current,
+ "expression",
+ lv_expression_6_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpressionInClosure");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ otherlv_7=(Token)match(input,26,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_7, grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXClosure"
+
+
+ // $ANTLR start "entryRuleXExpressionInClosure"
+ // InternalOXtype.g:3317:1: entryRuleXExpressionInClosure returns [EObject current=null] : iv_ruleXExpressionInClosure= ruleXExpressionInClosure EOF ;
+ public final EObject entryRuleXExpressionInClosure() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXExpressionInClosure = null;
+
+
+ try {
+ // InternalOXtype.g:3317:61: (iv_ruleXExpressionInClosure= ruleXExpressionInClosure EOF )
+ // InternalOXtype.g:3318:2: iv_ruleXExpressionInClosure= ruleXExpressionInClosure EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXExpressionInClosureRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXExpressionInClosure=ruleXExpressionInClosure();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXExpressionInClosure;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXExpressionInClosure"
+
+
+ // $ANTLR start "ruleXExpressionInClosure"
+ // InternalOXtype.g:3324:1: ruleXExpressionInClosure returns [EObject current=null] : ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* ) ;
+ public final EObject ruleXExpressionInClosure() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_2=null;
+ EObject lv_expressions_1_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:3330:2: ( ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* ) )
+ // InternalOXtype.g:3331:2: ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* )
+ {
+ // InternalOXtype.g:3331:2: ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* )
+ // InternalOXtype.g:3332:3: () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )*
+ {
+ // InternalOXtype.g:3332:3: ()
+ // InternalOXtype.g:3333:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:3339:3: ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )*
+ loop60:
+ do {
+ int alt60=2;
+ int LA60_0 = input.LA(1);
+
+ if ( ((LA60_0>=RULE_STRING && LA60_0<=RULE_ID)||(LA60_0>=13 && LA60_0<=15)||LA60_0==20||(LA60_0>=24 && LA60_0<=25)||LA60_0==32||(LA60_0>=48 && LA60_0<=49)||LA60_0==53||LA60_0==60||LA60_0==63||LA60_0==65||(LA60_0>=69 && LA60_0<=83)||LA60_0==85) ) {
+ alt60=1;
+ }
+
+
+ switch (alt60) {
+ case 1 :
+ // InternalOXtype.g:3340:4: ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )?
+ {
+ // InternalOXtype.g:3340:4: ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) )
+ // InternalOXtype.g:3341:5: (lv_expressions_1_0= ruleXExpressionOrVarDeclaration )
+ {
+ // InternalOXtype.g:3341:5: (lv_expressions_1_0= ruleXExpressionOrVarDeclaration )
+ // InternalOXtype.g:3342:6: lv_expressions_1_0= ruleXExpressionOrVarDeclaration
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0());
+
+ }
+ pushFollow(FOLLOW_50);
+ lv_expressions_1_0=ruleXExpressionOrVarDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXExpressionInClosureRule());
+ }
+ add(
+ current,
+ "expressions",
+ lv_expressions_1_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:3359:4: (otherlv_2= ';' )?
+ int alt59=2;
+ int LA59_0 = input.LA(1);
+
+ if ( (LA59_0==18) ) {
+ alt59=1;
+ }
+ switch (alt59) {
+ case 1 :
+ // InternalOXtype.g:3360:5: otherlv_2= ';'
+ {
+ otherlv_2=(Token)match(input,18,FOLLOW_51); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop60;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXExpressionInClosure"
+
+
+ // $ANTLR start "entryRuleXShortClosure"
+ // InternalOXtype.g:3370:1: entryRuleXShortClosure returns [EObject current=null] : iv_ruleXShortClosure= ruleXShortClosure EOF ;
+ public final EObject entryRuleXShortClosure() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXShortClosure = null;
+
+
+ try {
+ // InternalOXtype.g:3370:54: (iv_ruleXShortClosure= ruleXShortClosure EOF )
+ // InternalOXtype.g:3371:2: iv_ruleXShortClosure= ruleXShortClosure EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXShortClosureRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXShortClosure=ruleXShortClosure();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXShortClosure;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXShortClosure"
+
+
+ // $ANTLR start "ruleXShortClosure"
+ // InternalOXtype.g:3377:1: ruleXShortClosure returns [EObject current=null] : ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) ) ;
+ public final EObject ruleXShortClosure() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_2=null;
+ Token lv_explicitSyntax_4_0=null;
+ EObject lv_declaredFormalParameters_1_0 = null;
+
+ EObject lv_declaredFormalParameters_3_0 = null;
+
+ EObject lv_expression_5_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:3383:2: ( ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) ) )
+ // InternalOXtype.g:3384:2: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) )
+ {
+ // InternalOXtype.g:3384:2: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) )
+ // InternalOXtype.g:3385:3: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) )
+ {
+ // InternalOXtype.g:3385:3: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) )
+ // InternalOXtype.g:3386:4: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) )
+ {
+ // InternalOXtype.g:3411:4: ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) )
+ // InternalOXtype.g:3412:5: () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) )
+ {
+ // InternalOXtype.g:3412:5: ()
+ // InternalOXtype.g:3413:6:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:3419:5: ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )?
+ int alt62=2;
+ int LA62_0 = input.LA(1);
+
+ if ( (LA62_0==RULE_ID||LA62_0==20||LA62_0==45) ) {
+ alt62=1;
+ }
+ switch (alt62) {
+ case 1 :
+ // InternalOXtype.g:3420:6: ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )*
+ {
+ // InternalOXtype.g:3420:6: ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) )
+ // InternalOXtype.g:3421:7: (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:3421:7: (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter )
+ // InternalOXtype.g:3422:8: lv_declaredFormalParameters_1_0= ruleJvmFormalParameter
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0());
+
+ }
+ pushFollow(FOLLOW_47);
+ lv_declaredFormalParameters_1_0=ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXShortClosureRule());
+ }
+ add(
+ current,
+ "declaredFormalParameters",
+ lv_declaredFormalParameters_1_0,
+ "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:3439:6: (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )*
+ loop61:
+ do {
+ int alt61=2;
+ int LA61_0 = input.LA(1);
+
+ if ( (LA61_0==21) ) {
+ alt61=1;
+ }
+
+
+ switch (alt61) {
+ case 1 :
+ // InternalOXtype.g:3440:7: otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) )
+ {
+ otherlv_2=(Token)match(input,21,FOLLOW_26); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0());
+
+ }
+ // InternalOXtype.g:3444:7: ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) )
+ // InternalOXtype.g:3445:8: (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:3445:8: (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter )
+ // InternalOXtype.g:3446:9: lv_declaredFormalParameters_3_0= ruleJvmFormalParameter
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_47);
+ lv_declaredFormalParameters_3_0=ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXShortClosureRule());
+ }
+ add(
+ current,
+ "declaredFormalParameters",
+ lv_declaredFormalParameters_3_0,
+ "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop61;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:3465:5: ( (lv_explicitSyntax_4_0= '|' ) )
+ // InternalOXtype.g:3466:6: (lv_explicitSyntax_4_0= '|' )
+ {
+ // InternalOXtype.g:3466:6: (lv_explicitSyntax_4_0= '|' )
+ // InternalOXtype.g:3467:7: lv_explicitSyntax_4_0= '|'
+ {
+ lv_explicitSyntax_4_0=(Token)match(input,62,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_explicitSyntax_4_0, grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXShortClosureRule());
+ }
+ setWithLastConsumed(current, "explicitSyntax", true, "|");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:3481:3: ( (lv_expression_5_0= ruleXExpression ) )
+ // InternalOXtype.g:3482:4: (lv_expression_5_0= ruleXExpression )
+ {
+ // InternalOXtype.g:3482:4: (lv_expression_5_0= ruleXExpression )
+ // InternalOXtype.g:3483:5: lv_expression_5_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_expression_5_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXShortClosureRule());
+ }
+ set(
+ current,
+ "expression",
+ lv_expression_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXShortClosure"
+
+
+ // $ANTLR start "entryRuleXParenthesizedExpression"
+ // InternalOXtype.g:3504:1: entryRuleXParenthesizedExpression returns [EObject current=null] : iv_ruleXParenthesizedExpression= ruleXParenthesizedExpression EOF ;
+ public final EObject entryRuleXParenthesizedExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXParenthesizedExpression = null;
+
+
+ try {
+ // InternalOXtype.g:3504:65: (iv_ruleXParenthesizedExpression= ruleXParenthesizedExpression EOF )
+ // InternalOXtype.g:3505:2: iv_ruleXParenthesizedExpression= ruleXParenthesizedExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXParenthesizedExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXParenthesizedExpression=ruleXParenthesizedExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXParenthesizedExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXParenthesizedExpression"
+
+
+ // $ANTLR start "ruleXParenthesizedExpression"
+ // InternalOXtype.g:3511:1: ruleXParenthesizedExpression returns [EObject current=null] : (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' ) ;
+ public final EObject ruleXParenthesizedExpression() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+ Token otherlv_2=null;
+ EObject this_XExpression_1 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:3517:2: ( (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' ) )
+ // InternalOXtype.g:3518:2: (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' )
+ {
+ // InternalOXtype.g:3518:2: (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' )
+ // InternalOXtype.g:3519:3: otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')'
+ {
+ otherlv_0=(Token)match(input,20,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_0, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_11);
+ this_XExpression_1=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XExpression_1;
+ afterParserOrEnumRuleCall();
+
+ }
+ otherlv_2=(Token)match(input,22,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXParenthesizedExpression"
+
+
+ // $ANTLR start "entryRuleXIfExpression"
+ // InternalOXtype.g:3539:1: entryRuleXIfExpression returns [EObject current=null] : iv_ruleXIfExpression= ruleXIfExpression EOF ;
+ public final EObject entryRuleXIfExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXIfExpression = null;
+
+
+ try {
+ // InternalOXtype.g:3539:54: (iv_ruleXIfExpression= ruleXIfExpression EOF )
+ // InternalOXtype.g:3540:2: iv_ruleXIfExpression= ruleXIfExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXIfExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXIfExpression=ruleXIfExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXIfExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXIfExpression"
+
+
+ // $ANTLR start "ruleXIfExpression"
+ // InternalOXtype.g:3546:1: ruleXIfExpression returns [EObject current=null] : ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? ) ;
+ public final EObject ruleXIfExpression() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_2=null;
+ Token otherlv_4=null;
+ Token otherlv_6=null;
+ EObject lv_if_3_0 = null;
+
+ EObject lv_then_5_0 = null;
+
+ EObject lv_else_7_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:3552:2: ( ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? ) )
+ // InternalOXtype.g:3553:2: ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? )
+ {
+ // InternalOXtype.g:3553:2: ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? )
+ // InternalOXtype.g:3554:3: () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )?
+ {
+ // InternalOXtype.g:3554:3: ()
+ // InternalOXtype.g:3555:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,63,FOLLOW_52); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXIfExpressionAccess().getIfKeyword_1());
+
+ }
+ otherlv_2=(Token)match(input,20,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2());
+
+ }
+ // InternalOXtype.g:3569:3: ( (lv_if_3_0= ruleXExpression ) )
+ // InternalOXtype.g:3570:4: (lv_if_3_0= ruleXExpression )
+ {
+ // InternalOXtype.g:3570:4: (lv_if_3_0= ruleXExpression )
+ // InternalOXtype.g:3571:5: lv_if_3_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0());
+
+ }
+ pushFollow(FOLLOW_11);
+ lv_if_3_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXIfExpressionRule());
+ }
+ set(
+ current,
+ "if",
+ lv_if_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ otherlv_4=(Token)match(input,22,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_4, grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4());
+
+ }
+ // InternalOXtype.g:3592:3: ( (lv_then_5_0= ruleXExpression ) )
+ // InternalOXtype.g:3593:4: (lv_then_5_0= ruleXExpression )
+ {
+ // InternalOXtype.g:3593:4: (lv_then_5_0= ruleXExpression )
+ // InternalOXtype.g:3594:5: lv_then_5_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0());
+
+ }
+ pushFollow(FOLLOW_53);
+ lv_then_5_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXIfExpressionRule());
+ }
+ set(
+ current,
+ "then",
+ lv_then_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:3611:3: ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )?
+ int alt63=2;
+ int LA63_0 = input.LA(1);
+
+ if ( (LA63_0==64) ) {
+ int LA63_1 = input.LA(2);
+
+ if ( (synpred31_InternalOXtype()) ) {
+ alt63=1;
+ }
+ }
+ switch (alt63) {
+ case 1 :
+ // InternalOXtype.g:3612:4: ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) )
+ {
+ // InternalOXtype.g:3612:4: ( ( 'else' )=>otherlv_6= 'else' )
+ // InternalOXtype.g:3613:5: ( 'else' )=>otherlv_6= 'else'
+ {
+ otherlv_6=(Token)match(input,64,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_6, grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0());
+
+ }
+
+ }
+
+ // InternalOXtype.g:3619:4: ( (lv_else_7_0= ruleXExpression ) )
+ // InternalOXtype.g:3620:5: (lv_else_7_0= ruleXExpression )
+ {
+ // InternalOXtype.g:3620:5: (lv_else_7_0= ruleXExpression )
+ // InternalOXtype.g:3621:6: lv_else_7_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_else_7_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXIfExpressionRule());
+ }
+ set(
+ current,
+ "else",
+ lv_else_7_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXIfExpression"
+
+
+ // $ANTLR start "entryRuleXSwitchExpression"
+ // InternalOXtype.g:3643:1: entryRuleXSwitchExpression returns [EObject current=null] : iv_ruleXSwitchExpression= ruleXSwitchExpression EOF ;
+ public final EObject entryRuleXSwitchExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXSwitchExpression = null;
+
+
+ try {
+ // InternalOXtype.g:3643:58: (iv_ruleXSwitchExpression= ruleXSwitchExpression EOF )
+ // InternalOXtype.g:3644:2: iv_ruleXSwitchExpression= ruleXSwitchExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXSwitchExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXSwitchExpression=ruleXSwitchExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXSwitchExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXSwitchExpression"
+
+
+ // $ANTLR start "ruleXSwitchExpression"
+ // InternalOXtype.g:3650:1: ruleXSwitchExpression returns [EObject current=null] : ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' ) ;
+ public final EObject ruleXSwitchExpression() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_2=null;
+ Token otherlv_4=null;
+ Token otherlv_6=null;
+ Token otherlv_8=null;
+ Token otherlv_10=null;
+ Token otherlv_12=null;
+ Token otherlv_13=null;
+ Token otherlv_15=null;
+ EObject lv_declaredParam_3_0 = null;
+
+ EObject lv_switch_5_0 = null;
+
+ EObject lv_declaredParam_7_0 = null;
+
+ EObject lv_switch_9_0 = null;
+
+ EObject lv_cases_11_0 = null;
+
+ EObject lv_default_14_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:3656:2: ( ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' ) )
+ // InternalOXtype.g:3657:2: ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' )
+ {
+ // InternalOXtype.g:3657:2: ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' )
+ // InternalOXtype.g:3658:3: () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}'
+ {
+ // InternalOXtype.g:3658:3: ()
+ // InternalOXtype.g:3659:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,65,FOLLOW_54); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1());
+
+ }
+ // InternalOXtype.g:3669:3: ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) )
+ int alt65=2;
+ alt65 = dfa65.predict(input);
+ switch (alt65) {
+ case 1 :
+ // InternalOXtype.g:3670:4: ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' )
+ {
+ // InternalOXtype.g:3670:4: ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' )
+ // InternalOXtype.g:3671:5: ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')'
+ {
+ // InternalOXtype.g:3671:5: ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) )
+ // InternalOXtype.g:3672:6: ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' )
+ {
+ // InternalOXtype.g:3682:6: (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' )
+ // InternalOXtype.g:3683:7: otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':'
+ {
+ otherlv_2=(Token)match(input,20,FOLLOW_26); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0());
+
+ }
+ // InternalOXtype.g:3687:7: ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) )
+ // InternalOXtype.g:3688:8: (lv_declaredParam_3_0= ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:3688:8: (lv_declaredParam_3_0= ruleJvmFormalParameter )
+ // InternalOXtype.g:3689:9: lv_declaredParam_3_0= ruleJvmFormalParameter
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0());
+
+ }
+ pushFollow(FOLLOW_55);
+ lv_declaredParam_3_0=ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ set(
+ current,
+ "declaredParam",
+ lv_declaredParam_3_0,
+ "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ otherlv_4=(Token)match(input,66,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_4, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2());
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:3712:5: ( (lv_switch_5_0= ruleXExpression ) )
+ // InternalOXtype.g:3713:6: (lv_switch_5_0= ruleXExpression )
+ {
+ // InternalOXtype.g:3713:6: (lv_switch_5_0= ruleXExpression )
+ // InternalOXtype.g:3714:7: lv_switch_5_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0());
+
+ }
+ pushFollow(FOLLOW_11);
+ lv_switch_5_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ set(
+ current,
+ "switch",
+ lv_switch_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ otherlv_6=(Token)match(input,22,FOLLOW_43); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_6, grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:3737:4: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) )
+ {
+ // InternalOXtype.g:3737:4: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) )
+ // InternalOXtype.g:3738:5: ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) )
+ {
+ // InternalOXtype.g:3738:5: ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )?
+ int alt64=2;
+ alt64 = dfa64.predict(input);
+ switch (alt64) {
+ case 1 :
+ // InternalOXtype.g:3739:6: ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' )
+ {
+ // InternalOXtype.g:3748:6: ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' )
+ // InternalOXtype.g:3749:7: ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':'
+ {
+ // InternalOXtype.g:3749:7: ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) )
+ // InternalOXtype.g:3750:8: (lv_declaredParam_7_0= ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:3750:8: (lv_declaredParam_7_0= ruleJvmFormalParameter )
+ // InternalOXtype.g:3751:9: lv_declaredParam_7_0= ruleJvmFormalParameter
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0());
+
+ }
+ pushFollow(FOLLOW_55);
+ lv_declaredParam_7_0=ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ set(
+ current,
+ "declaredParam",
+ lv_declaredParam_7_0,
+ "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ otherlv_8=(Token)match(input,66,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_8, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:3774:5: ( (lv_switch_9_0= ruleXExpression ) )
+ // InternalOXtype.g:3775:6: (lv_switch_9_0= ruleXExpression )
+ {
+ // InternalOXtype.g:3775:6: (lv_switch_9_0= ruleXExpression )
+ // InternalOXtype.g:3776:7: lv_switch_9_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0());
+
+ }
+ pushFollow(FOLLOW_43);
+ lv_switch_9_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ set(
+ current,
+ "switch",
+ lv_switch_9_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ otherlv_10=(Token)match(input,60,FOLLOW_56); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_10, grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3());
+
+ }
+ // InternalOXtype.g:3799:3: ( (lv_cases_11_0= ruleXCasePart ) )*
+ loop66:
+ do {
+ int alt66=2;
+ int LA66_0 = input.LA(1);
+
+ if ( (LA66_0==RULE_ID||(LA66_0>=20 && LA66_0<=21)||LA66_0==45||LA66_0==66||LA66_0==68) ) {
+ alt66=1;
+ }
+
+
+ switch (alt66) {
+ case 1 :
+ // InternalOXtype.g:3800:4: (lv_cases_11_0= ruleXCasePart )
+ {
+ // InternalOXtype.g:3800:4: (lv_cases_11_0= ruleXCasePart )
+ // InternalOXtype.g:3801:5: lv_cases_11_0= ruleXCasePart
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0());
+
+ }
+ pushFollow(FOLLOW_56);
+ lv_cases_11_0=ruleXCasePart();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ add(
+ current,
+ "cases",
+ lv_cases_11_0,
+ "org.eclipse.xtext.xbase.Xbase.XCasePart");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop66;
+ }
+ } while (true);
+
+ // InternalOXtype.g:3818:3: (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )?
+ int alt67=2;
+ int LA67_0 = input.LA(1);
+
+ if ( (LA67_0==67) ) {
+ alt67=1;
+ }
+ switch (alt67) {
+ case 1 :
+ // InternalOXtype.g:3819:4: otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) )
+ {
+ otherlv_12=(Token)match(input,67,FOLLOW_55); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_12, grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0());
+
+ }
+ otherlv_13=(Token)match(input,66,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_13, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1());
+
+ }
+ // InternalOXtype.g:3827:4: ( (lv_default_14_0= ruleXExpression ) )
+ // InternalOXtype.g:3828:5: (lv_default_14_0= ruleXExpression )
+ {
+ // InternalOXtype.g:3828:5: (lv_default_14_0= ruleXExpression )
+ // InternalOXtype.g:3829:6: lv_default_14_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0());
+
+ }
+ pushFollow(FOLLOW_57);
+ lv_default_14_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ set(
+ current,
+ "default",
+ lv_default_14_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ otherlv_15=(Token)match(input,61,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_15, grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXSwitchExpression"
+
+
+ // $ANTLR start "entryRuleXCasePart"
+ // InternalOXtype.g:3855:1: entryRuleXCasePart returns [EObject current=null] : iv_ruleXCasePart= ruleXCasePart EOF ;
+ public final EObject entryRuleXCasePart() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXCasePart = null;
+
+
+ try {
+ // InternalOXtype.g:3855:50: (iv_ruleXCasePart= ruleXCasePart EOF )
+ // InternalOXtype.g:3856:2: iv_ruleXCasePart= ruleXCasePart EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXCasePartRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXCasePart=ruleXCasePart();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXCasePart;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXCasePart"
+
+
+ // $ANTLR start "ruleXCasePart"
+ // InternalOXtype.g:3862:1: ruleXCasePart returns [EObject current=null] : ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) ) ;
+ public final EObject ruleXCasePart() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_2=null;
+ Token otherlv_4=null;
+ Token lv_fallThrough_6_0=null;
+ EObject lv_typeGuard_1_0 = null;
+
+ EObject lv_case_3_0 = null;
+
+ EObject lv_then_5_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:3868:2: ( ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) ) )
+ // InternalOXtype.g:3869:2: ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) )
+ {
+ // InternalOXtype.g:3869:2: ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) )
+ // InternalOXtype.g:3870:3: () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) )
+ {
+ // InternalOXtype.g:3870:3: ()
+ // InternalOXtype.g:3871:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXCasePartAccess().getXCasePartAction_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:3877:3: ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )?
+ int alt68=2;
+ int LA68_0 = input.LA(1);
+
+ if ( (LA68_0==RULE_ID||LA68_0==20||LA68_0==45) ) {
+ alt68=1;
+ }
+ switch (alt68) {
+ case 1 :
+ // InternalOXtype.g:3878:4: (lv_typeGuard_1_0= ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:3878:4: (lv_typeGuard_1_0= ruleJvmTypeReference )
+ // InternalOXtype.g:3879:5: lv_typeGuard_1_0= ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_58);
+ lv_typeGuard_1_0=ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXCasePartRule());
+ }
+ set(
+ current,
+ "typeGuard",
+ lv_typeGuard_1_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:3896:3: (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )?
+ int alt69=2;
+ int LA69_0 = input.LA(1);
+
+ if ( (LA69_0==68) ) {
+ alt69=1;
+ }
+ switch (alt69) {
+ case 1 :
+ // InternalOXtype.g:3897:4: otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) )
+ {
+ otherlv_2=(Token)match(input,68,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXCasePartAccess().getCaseKeyword_2_0());
+
+ }
+ // InternalOXtype.g:3901:4: ( (lv_case_3_0= ruleXExpression ) )
+ // InternalOXtype.g:3902:5: (lv_case_3_0= ruleXExpression )
+ {
+ // InternalOXtype.g:3902:5: (lv_case_3_0= ruleXExpression )
+ // InternalOXtype.g:3903:6: lv_case_3_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0());
+
+ }
+ pushFollow(FOLLOW_59);
+ lv_case_3_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXCasePartRule());
+ }
+ set(
+ current,
+ "case",
+ lv_case_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:3921:3: ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) )
+ int alt70=2;
+ int LA70_0 = input.LA(1);
+
+ if ( (LA70_0==66) ) {
+ alt70=1;
+ }
+ else if ( (LA70_0==21) ) {
+ alt70=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 70, 0, input);
+
+ throw nvae;
+ }
+ switch (alt70) {
+ case 1 :
+ // InternalOXtype.g:3922:4: (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) )
+ {
+ // InternalOXtype.g:3922:4: (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) )
+ // InternalOXtype.g:3923:5: otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) )
+ {
+ otherlv_4=(Token)match(input,66,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_4, grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0());
+
+ }
+ // InternalOXtype.g:3927:5: ( (lv_then_5_0= ruleXExpression ) )
+ // InternalOXtype.g:3928:6: (lv_then_5_0= ruleXExpression )
+ {
+ // InternalOXtype.g:3928:6: (lv_then_5_0= ruleXExpression )
+ // InternalOXtype.g:3929:7: lv_then_5_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_then_5_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXCasePartRule());
+ }
+ set(
+ current,
+ "then",
+ lv_then_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:3948:4: ( (lv_fallThrough_6_0= ',' ) )
+ {
+ // InternalOXtype.g:3948:4: ( (lv_fallThrough_6_0= ',' ) )
+ // InternalOXtype.g:3949:5: (lv_fallThrough_6_0= ',' )
+ {
+ // InternalOXtype.g:3949:5: (lv_fallThrough_6_0= ',' )
+ // InternalOXtype.g:3950:6: lv_fallThrough_6_0= ','
+ {
+ lv_fallThrough_6_0=(Token)match(input,21,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_fallThrough_6_0, grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXCasePartRule());
+ }
+ setWithLastConsumed(current, "fallThrough", true, ",");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXCasePart"
+
+
+ // $ANTLR start "entryRuleXForLoopExpression"
+ // InternalOXtype.g:3967:1: entryRuleXForLoopExpression returns [EObject current=null] : iv_ruleXForLoopExpression= ruleXForLoopExpression EOF ;
+ public final EObject entryRuleXForLoopExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXForLoopExpression = null;
+
+
+ try {
+ // InternalOXtype.g:3967:59: (iv_ruleXForLoopExpression= ruleXForLoopExpression EOF )
+ // InternalOXtype.g:3968:2: iv_ruleXForLoopExpression= ruleXForLoopExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXForLoopExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXForLoopExpression=ruleXForLoopExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXForLoopExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXForLoopExpression"
+
+
+ // $ANTLR start "ruleXForLoopExpression"
+ // InternalOXtype.g:3974:1: ruleXForLoopExpression returns [EObject current=null] : ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) ) ;
+ public final EObject ruleXForLoopExpression() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_2=null;
+ Token otherlv_4=null;
+ Token otherlv_6=null;
+ EObject lv_declaredParam_3_0 = null;
+
+ EObject lv_forExpression_5_0 = null;
+
+ EObject lv_eachExpression_7_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:3980:2: ( ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) ) )
+ // InternalOXtype.g:3981:2: ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) )
+ {
+ // InternalOXtype.g:3981:2: ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) )
+ // InternalOXtype.g:3982:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) )
+ {
+ // InternalOXtype.g:3982:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) )
+ // InternalOXtype.g:3983:4: ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' )
+ {
+ // InternalOXtype.g:3996:4: ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' )
+ // InternalOXtype.g:3997:5: () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':'
+ {
+ // InternalOXtype.g:3997:5: ()
+ // InternalOXtype.g:3998:6:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,69,FOLLOW_52); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1());
+
+ }
+ otherlv_2=(Token)match(input,20,FOLLOW_26); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2());
+
+ }
+ // InternalOXtype.g:4012:5: ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) )
+ // InternalOXtype.g:4013:6: (lv_declaredParam_3_0= ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:4013:6: (lv_declaredParam_3_0= ruleJvmFormalParameter )
+ // InternalOXtype.g:4014:7: lv_declaredParam_3_0= ruleJvmFormalParameter
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0());
+
+ }
+ pushFollow(FOLLOW_55);
+ lv_declaredParam_3_0=ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule());
+ }
+ set(
+ current,
+ "declaredParam",
+ lv_declaredParam_3_0,
+ "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ otherlv_4=(Token)match(input,66,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_4, grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4());
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:4037:3: ( (lv_forExpression_5_0= ruleXExpression ) )
+ // InternalOXtype.g:4038:4: (lv_forExpression_5_0= ruleXExpression )
+ {
+ // InternalOXtype.g:4038:4: (lv_forExpression_5_0= ruleXExpression )
+ // InternalOXtype.g:4039:5: lv_forExpression_5_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_11);
+ lv_forExpression_5_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule());
+ }
+ set(
+ current,
+ "forExpression",
+ lv_forExpression_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ otherlv_6=(Token)match(input,22,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_6, grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2());
+
+ }
+ // InternalOXtype.g:4060:3: ( (lv_eachExpression_7_0= ruleXExpression ) )
+ // InternalOXtype.g:4061:4: (lv_eachExpression_7_0= ruleXExpression )
+ {
+ // InternalOXtype.g:4061:4: (lv_eachExpression_7_0= ruleXExpression )
+ // InternalOXtype.g:4062:5: lv_eachExpression_7_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_eachExpression_7_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule());
+ }
+ set(
+ current,
+ "eachExpression",
+ lv_eachExpression_7_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXForLoopExpression"
+
+
+ // $ANTLR start "entryRuleXBasicForLoopExpression"
+ // InternalOXtype.g:4083:1: entryRuleXBasicForLoopExpression returns [EObject current=null] : iv_ruleXBasicForLoopExpression= ruleXBasicForLoopExpression EOF ;
+ public final EObject entryRuleXBasicForLoopExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXBasicForLoopExpression = null;
+
+
+ try {
+ // InternalOXtype.g:4083:64: (iv_ruleXBasicForLoopExpression= ruleXBasicForLoopExpression EOF )
+ // InternalOXtype.g:4084:2: iv_ruleXBasicForLoopExpression= ruleXBasicForLoopExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXBasicForLoopExpression=ruleXBasicForLoopExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXBasicForLoopExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXBasicForLoopExpression"
+
+
+ // $ANTLR start "ruleXBasicForLoopExpression"
+ // InternalOXtype.g:4090:1: ruleXBasicForLoopExpression returns [EObject current=null] : ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) ) ;
+ public final EObject ruleXBasicForLoopExpression() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_2=null;
+ Token otherlv_4=null;
+ Token otherlv_6=null;
+ Token otherlv_8=null;
+ Token otherlv_10=null;
+ Token otherlv_12=null;
+ EObject lv_initExpressions_3_0 = null;
+
+ EObject lv_initExpressions_5_0 = null;
+
+ EObject lv_expression_7_0 = null;
+
+ EObject lv_updateExpressions_9_0 = null;
+
+ EObject lv_updateExpressions_11_0 = null;
+
+ EObject lv_eachExpression_13_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:4096:2: ( ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) ) )
+ // InternalOXtype.g:4097:2: ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) )
+ {
+ // InternalOXtype.g:4097:2: ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) )
+ // InternalOXtype.g:4098:3: () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) )
+ {
+ // InternalOXtype.g:4098:3: ()
+ // InternalOXtype.g:4099:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,69,FOLLOW_52); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1());
+
+ }
+ otherlv_2=(Token)match(input,20,FOLLOW_60); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2());
+
+ }
+ // InternalOXtype.g:4113:3: ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )?
+ int alt72=2;
+ int LA72_0 = input.LA(1);
+
+ if ( ((LA72_0>=RULE_STRING && LA72_0<=RULE_ID)||(LA72_0>=13 && LA72_0<=15)||LA72_0==20||(LA72_0>=24 && LA72_0<=25)||LA72_0==32||(LA72_0>=48 && LA72_0<=49)||LA72_0==53||LA72_0==60||LA72_0==63||LA72_0==65||(LA72_0>=69 && LA72_0<=83)||LA72_0==85) ) {
+ alt72=1;
+ }
+ switch (alt72) {
+ case 1 :
+ // InternalOXtype.g:4114:4: ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )*
+ {
+ // InternalOXtype.g:4114:4: ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) )
+ // InternalOXtype.g:4115:5: (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration )
+ {
+ // InternalOXtype.g:4115:5: (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration )
+ // InternalOXtype.g:4116:6: lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0());
+
+ }
+ pushFollow(FOLLOW_61);
+ lv_initExpressions_3_0=ruleXExpressionOrVarDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ add(
+ current,
+ "initExpressions",
+ lv_initExpressions_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:4133:4: (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )*
+ loop71:
+ do {
+ int alt71=2;
+ int LA71_0 = input.LA(1);
+
+ if ( (LA71_0==21) ) {
+ alt71=1;
+ }
+
+
+ switch (alt71) {
+ case 1 :
+ // InternalOXtype.g:4134:5: otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) )
+ {
+ otherlv_4=(Token)match(input,21,FOLLOW_62); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_4, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0());
+
+ }
+ // InternalOXtype.g:4138:5: ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) )
+ // InternalOXtype.g:4139:6: (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration )
+ {
+ // InternalOXtype.g:4139:6: (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration )
+ // InternalOXtype.g:4140:7: lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0());
+
+ }
+ pushFollow(FOLLOW_61);
+ lv_initExpressions_5_0=ruleXExpressionOrVarDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ add(
+ current,
+ "initExpressions",
+ lv_initExpressions_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop71;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ otherlv_6=(Token)match(input,18,FOLLOW_63); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_6, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4());
+
+ }
+ // InternalOXtype.g:4163:3: ( (lv_expression_7_0= ruleXExpression ) )?
+ int alt73=2;
+ int LA73_0 = input.LA(1);
+
+ if ( ((LA73_0>=RULE_STRING && LA73_0<=RULE_ID)||(LA73_0>=13 && LA73_0<=15)||LA73_0==20||(LA73_0>=24 && LA73_0<=25)||LA73_0==32||(LA73_0>=48 && LA73_0<=49)||LA73_0==53||LA73_0==60||LA73_0==63||LA73_0==65||(LA73_0>=69 && LA73_0<=71)||(LA73_0>=74 && LA73_0<=83)||LA73_0==85) ) {
+ alt73=1;
+ }
+ switch (alt73) {
+ case 1 :
+ // InternalOXtype.g:4164:4: (lv_expression_7_0= ruleXExpression )
+ {
+ // InternalOXtype.g:4164:4: (lv_expression_7_0= ruleXExpression )
+ // InternalOXtype.g:4165:5: lv_expression_7_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0());
+
+ }
+ pushFollow(FOLLOW_64);
+ lv_expression_7_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ set(
+ current,
+ "expression",
+ lv_expression_7_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ otherlv_8=(Token)match(input,18,FOLLOW_9); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_8, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6());
+
+ }
+ // InternalOXtype.g:4186:3: ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )?
+ int alt75=2;
+ int LA75_0 = input.LA(1);
+
+ if ( ((LA75_0>=RULE_STRING && LA75_0<=RULE_ID)||(LA75_0>=13 && LA75_0<=15)||LA75_0==20||(LA75_0>=24 && LA75_0<=25)||LA75_0==32||(LA75_0>=48 && LA75_0<=49)||LA75_0==53||LA75_0==60||LA75_0==63||LA75_0==65||(LA75_0>=69 && LA75_0<=71)||(LA75_0>=74 && LA75_0<=83)||LA75_0==85) ) {
+ alt75=1;
+ }
+ switch (alt75) {
+ case 1 :
+ // InternalOXtype.g:4187:4: ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )*
+ {
+ // InternalOXtype.g:4187:4: ( (lv_updateExpressions_9_0= ruleXExpression ) )
+ // InternalOXtype.g:4188:5: (lv_updateExpressions_9_0= ruleXExpression )
+ {
+ // InternalOXtype.g:4188:5: (lv_updateExpressions_9_0= ruleXExpression )
+ // InternalOXtype.g:4189:6: lv_updateExpressions_9_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0());
+
+ }
+ pushFollow(FOLLOW_10);
+ lv_updateExpressions_9_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ add(
+ current,
+ "updateExpressions",
+ lv_updateExpressions_9_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:4206:4: (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )*
+ loop74:
+ do {
+ int alt74=2;
+ int LA74_0 = input.LA(1);
+
+ if ( (LA74_0==21) ) {
+ alt74=1;
+ }
+
+
+ switch (alt74) {
+ case 1 :
+ // InternalOXtype.g:4207:5: otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) )
+ {
+ otherlv_10=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_10, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0());
+
+ }
+ // InternalOXtype.g:4211:5: ( (lv_updateExpressions_11_0= ruleXExpression ) )
+ // InternalOXtype.g:4212:6: (lv_updateExpressions_11_0= ruleXExpression )
+ {
+ // InternalOXtype.g:4212:6: (lv_updateExpressions_11_0= ruleXExpression )
+ // InternalOXtype.g:4213:7: lv_updateExpressions_11_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0());
+
+ }
+ pushFollow(FOLLOW_10);
+ lv_updateExpressions_11_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ add(
+ current,
+ "updateExpressions",
+ lv_updateExpressions_11_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop74;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ otherlv_12=(Token)match(input,22,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_12, grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8());
+
+ }
+ // InternalOXtype.g:4236:3: ( (lv_eachExpression_13_0= ruleXExpression ) )
+ // InternalOXtype.g:4237:4: (lv_eachExpression_13_0= ruleXExpression )
+ {
+ // InternalOXtype.g:4237:4: (lv_eachExpression_13_0= ruleXExpression )
+ // InternalOXtype.g:4238:5: lv_eachExpression_13_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_eachExpression_13_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ set(
+ current,
+ "eachExpression",
+ lv_eachExpression_13_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXBasicForLoopExpression"
+
+
+ // $ANTLR start "entryRuleXWhileExpression"
+ // InternalOXtype.g:4259:1: entryRuleXWhileExpression returns [EObject current=null] : iv_ruleXWhileExpression= ruleXWhileExpression EOF ;
+ public final EObject entryRuleXWhileExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXWhileExpression = null;
+
+
+ try {
+ // InternalOXtype.g:4259:57: (iv_ruleXWhileExpression= ruleXWhileExpression EOF )
+ // InternalOXtype.g:4260:2: iv_ruleXWhileExpression= ruleXWhileExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXWhileExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXWhileExpression=ruleXWhileExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXWhileExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXWhileExpression"
+
+
+ // $ANTLR start "ruleXWhileExpression"
+ // InternalOXtype.g:4266:1: ruleXWhileExpression returns [EObject current=null] : ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) ) ;
+ public final EObject ruleXWhileExpression() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_2=null;
+ Token otherlv_4=null;
+ EObject lv_predicate_3_0 = null;
+
+ EObject lv_body_5_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:4272:2: ( ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) ) )
+ // InternalOXtype.g:4273:2: ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) )
+ {
+ // InternalOXtype.g:4273:2: ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) )
+ // InternalOXtype.g:4274:3: () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) )
+ {
+ // InternalOXtype.g:4274:3: ()
+ // InternalOXtype.g:4275:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,70,FOLLOW_52); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1());
+
+ }
+ otherlv_2=(Token)match(input,20,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2());
+
+ }
+ // InternalOXtype.g:4289:3: ( (lv_predicate_3_0= ruleXExpression ) )
+ // InternalOXtype.g:4290:4: (lv_predicate_3_0= ruleXExpression )
+ {
+ // InternalOXtype.g:4290:4: (lv_predicate_3_0= ruleXExpression )
+ // InternalOXtype.g:4291:5: lv_predicate_3_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0());
+
+ }
+ pushFollow(FOLLOW_11);
+ lv_predicate_3_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXWhileExpressionRule());
+ }
+ set(
+ current,
+ "predicate",
+ lv_predicate_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ otherlv_4=(Token)match(input,22,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_4, grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4());
+
+ }
+ // InternalOXtype.g:4312:3: ( (lv_body_5_0= ruleXExpression ) )
+ // InternalOXtype.g:4313:4: (lv_body_5_0= ruleXExpression )
+ {
+ // InternalOXtype.g:4313:4: (lv_body_5_0= ruleXExpression )
+ // InternalOXtype.g:4314:5: lv_body_5_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_body_5_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXWhileExpressionRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXWhileExpression"
+
+
+ // $ANTLR start "entryRuleXDoWhileExpression"
+ // InternalOXtype.g:4335:1: entryRuleXDoWhileExpression returns [EObject current=null] : iv_ruleXDoWhileExpression= ruleXDoWhileExpression EOF ;
+ public final EObject entryRuleXDoWhileExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXDoWhileExpression = null;
+
+
+ try {
+ // InternalOXtype.g:4335:59: (iv_ruleXDoWhileExpression= ruleXDoWhileExpression EOF )
+ // InternalOXtype.g:4336:2: iv_ruleXDoWhileExpression= ruleXDoWhileExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXDoWhileExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXDoWhileExpression=ruleXDoWhileExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXDoWhileExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXDoWhileExpression"
+
+
+ // $ANTLR start "ruleXDoWhileExpression"
+ // InternalOXtype.g:4342:1: ruleXDoWhileExpression returns [EObject current=null] : ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' ) ;
+ public final EObject ruleXDoWhileExpression() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_3=null;
+ Token otherlv_4=null;
+ Token otherlv_6=null;
+ EObject lv_body_2_0 = null;
+
+ EObject lv_predicate_5_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:4348:2: ( ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' ) )
+ // InternalOXtype.g:4349:2: ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' )
+ {
+ // InternalOXtype.g:4349:2: ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' )
+ // InternalOXtype.g:4350:3: () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')'
+ {
+ // InternalOXtype.g:4350:3: ()
+ // InternalOXtype.g:4351:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,71,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1());
+
+ }
+ // InternalOXtype.g:4361:3: ( (lv_body_2_0= ruleXExpression ) )
+ // InternalOXtype.g:4362:4: (lv_body_2_0= ruleXExpression )
+ {
+ // InternalOXtype.g:4362:4: (lv_body_2_0= ruleXExpression )
+ // InternalOXtype.g:4363:5: lv_body_2_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_65);
+ lv_body_2_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_2_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ otherlv_3=(Token)match(input,70,FOLLOW_52); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_3, grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3());
+
+ }
+ otherlv_4=(Token)match(input,20,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_4, grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4());
+
+ }
+ // InternalOXtype.g:4388:3: ( (lv_predicate_5_0= ruleXExpression ) )
+ // InternalOXtype.g:4389:4: (lv_predicate_5_0= ruleXExpression )
+ {
+ // InternalOXtype.g:4389:4: (lv_predicate_5_0= ruleXExpression )
+ // InternalOXtype.g:4390:5: lv_predicate_5_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0());
+
+ }
+ pushFollow(FOLLOW_11);
+ lv_predicate_5_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule());
+ }
+ set(
+ current,
+ "predicate",
+ lv_predicate_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ otherlv_6=(Token)match(input,22,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_6, grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXDoWhileExpression"
+
+
+ // $ANTLR start "entryRuleXBlockExpression"
+ // InternalOXtype.g:4415:1: entryRuleXBlockExpression returns [EObject current=null] : iv_ruleXBlockExpression= ruleXBlockExpression EOF ;
+ public final EObject entryRuleXBlockExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXBlockExpression = null;
+
+
+ try {
+ // InternalOXtype.g:4415:57: (iv_ruleXBlockExpression= ruleXBlockExpression EOF )
+ // InternalOXtype.g:4416:2: iv_ruleXBlockExpression= ruleXBlockExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXBlockExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXBlockExpression=ruleXBlockExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXBlockExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXBlockExpression"
+
+
+ // $ANTLR start "ruleXBlockExpression"
+ // InternalOXtype.g:4422:1: ruleXBlockExpression returns [EObject current=null] : ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' ) ;
+ public final EObject ruleXBlockExpression() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_3=null;
+ Token otherlv_4=null;
+ EObject lv_expressions_2_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:4428:2: ( ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' ) )
+ // InternalOXtype.g:4429:2: ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' )
+ {
+ // InternalOXtype.g:4429:2: ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' )
+ // InternalOXtype.g:4430:3: () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}'
+ {
+ // InternalOXtype.g:4430:3: ()
+ // InternalOXtype.g:4431:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,60,FOLLOW_66); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1());
+
+ }
+ // InternalOXtype.g:4441:3: ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )*
+ loop77:
+ do {
+ int alt77=2;
+ int LA77_0 = input.LA(1);
+
+ if ( ((LA77_0>=RULE_STRING && LA77_0<=RULE_ID)||(LA77_0>=13 && LA77_0<=15)||LA77_0==20||(LA77_0>=24 && LA77_0<=25)||LA77_0==32||(LA77_0>=48 && LA77_0<=49)||LA77_0==53||LA77_0==60||LA77_0==63||LA77_0==65||(LA77_0>=69 && LA77_0<=83)||LA77_0==85) ) {
+ alt77=1;
+ }
+
+
+ switch (alt77) {
+ case 1 :
+ // InternalOXtype.g:4442:4: ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )?
+ {
+ // InternalOXtype.g:4442:4: ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) )
+ // InternalOXtype.g:4443:5: (lv_expressions_2_0= ruleXExpressionOrVarDeclaration )
+ {
+ // InternalOXtype.g:4443:5: (lv_expressions_2_0= ruleXExpressionOrVarDeclaration )
+ // InternalOXtype.g:4444:6: lv_expressions_2_0= ruleXExpressionOrVarDeclaration
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0());
+
+ }
+ pushFollow(FOLLOW_67);
+ lv_expressions_2_0=ruleXExpressionOrVarDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXBlockExpressionRule());
+ }
+ add(
+ current,
+ "expressions",
+ lv_expressions_2_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:4461:4: (otherlv_3= ';' )?
+ int alt76=2;
+ int LA76_0 = input.LA(1);
+
+ if ( (LA76_0==18) ) {
+ alt76=1;
+ }
+ switch (alt76) {
+ case 1 :
+ // InternalOXtype.g:4462:5: otherlv_3= ';'
+ {
+ otherlv_3=(Token)match(input,18,FOLLOW_66); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_3, grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop77;
+ }
+ } while (true);
+
+ otherlv_4=(Token)match(input,61,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_4, grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXBlockExpression"
+
+
+ // $ANTLR start "entryRuleXExpressionOrVarDeclaration"
+ // InternalOXtype.g:4476:1: entryRuleXExpressionOrVarDeclaration returns [EObject current=null] : iv_ruleXExpressionOrVarDeclaration= ruleXExpressionOrVarDeclaration EOF ;
+ public final EObject entryRuleXExpressionOrVarDeclaration() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXExpressionOrVarDeclaration = null;
+
+
+ try {
+ // InternalOXtype.g:4476:68: (iv_ruleXExpressionOrVarDeclaration= ruleXExpressionOrVarDeclaration EOF )
+ // InternalOXtype.g:4477:2: iv_ruleXExpressionOrVarDeclaration= ruleXExpressionOrVarDeclaration EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXExpressionOrVarDeclaration=ruleXExpressionOrVarDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXExpressionOrVarDeclaration;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXExpressionOrVarDeclaration"
+
+
+ // $ANTLR start "ruleXExpressionOrVarDeclaration"
+ // InternalOXtype.g:4483:1: ruleXExpressionOrVarDeclaration returns [EObject current=null] : (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression ) ;
+ public final EObject ruleXExpressionOrVarDeclaration() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_XVariableDeclaration_0 = null;
+
+ EObject this_XExpression_1 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:4489:2: ( (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression ) )
+ // InternalOXtype.g:4490:2: (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression )
+ {
+ // InternalOXtype.g:4490:2: (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression )
+ int alt78=2;
+ int LA78_0 = input.LA(1);
+
+ if ( ((LA78_0>=72 && LA78_0<=73)) ) {
+ alt78=1;
+ }
+ else if ( ((LA78_0>=RULE_STRING && LA78_0<=RULE_ID)||(LA78_0>=13 && LA78_0<=15)||LA78_0==20||(LA78_0>=24 && LA78_0<=25)||LA78_0==32||(LA78_0>=48 && LA78_0<=49)||LA78_0==53||LA78_0==60||LA78_0==63||LA78_0==65||(LA78_0>=69 && LA78_0<=71)||(LA78_0>=74 && LA78_0<=83)||LA78_0==85) ) {
+ alt78=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 78, 0, input);
+
+ throw nvae;
+ }
+ switch (alt78) {
+ case 1 :
+ // InternalOXtype.g:4491:3: this_XVariableDeclaration_0= ruleXVariableDeclaration
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XVariableDeclaration_0=ruleXVariableDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XVariableDeclaration_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:4500:3: this_XExpression_1= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XExpression_1=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XExpression_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXExpressionOrVarDeclaration"
+
+
+ // $ANTLR start "entryRuleXVariableDeclaration"
+ // InternalOXtype.g:4512:1: entryRuleXVariableDeclaration returns [EObject current=null] : iv_ruleXVariableDeclaration= ruleXVariableDeclaration EOF ;
+ public final EObject entryRuleXVariableDeclaration() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXVariableDeclaration = null;
+
+
+ try {
+ // InternalOXtype.g:4512:61: (iv_ruleXVariableDeclaration= ruleXVariableDeclaration EOF )
+ // InternalOXtype.g:4513:2: iv_ruleXVariableDeclaration= ruleXVariableDeclaration EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXVariableDeclarationRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXVariableDeclaration=ruleXVariableDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXVariableDeclaration;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXVariableDeclaration"
+
+
+ // $ANTLR start "ruleXVariableDeclaration"
+ // InternalOXtype.g:4519:1: ruleXVariableDeclaration returns [EObject current=null] : ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? ) ;
+ public final EObject ruleXVariableDeclaration() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_writeable_1_0=null;
+ Token otherlv_2=null;
+ Token otherlv_6=null;
+ EObject lv_type_3_0 = null;
+
+ AntlrDatatypeRuleToken lv_name_4_0 = null;
+
+ AntlrDatatypeRuleToken lv_name_5_0 = null;
+
+ EObject lv_right_7_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:4525:2: ( ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? ) )
+ // InternalOXtype.g:4526:2: ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? )
+ {
+ // InternalOXtype.g:4526:2: ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? )
+ // InternalOXtype.g:4527:3: () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )?
+ {
+ // InternalOXtype.g:4527:3: ()
+ // InternalOXtype.g:4528:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:4534:3: ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' )
+ int alt79=2;
+ int LA79_0 = input.LA(1);
+
+ if ( (LA79_0==72) ) {
+ alt79=1;
+ }
+ else if ( (LA79_0==73) ) {
+ alt79=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 79, 0, input);
+
+ throw nvae;
+ }
+ switch (alt79) {
+ case 1 :
+ // InternalOXtype.g:4535:4: ( (lv_writeable_1_0= 'var' ) )
+ {
+ // InternalOXtype.g:4535:4: ( (lv_writeable_1_0= 'var' ) )
+ // InternalOXtype.g:4536:5: (lv_writeable_1_0= 'var' )
+ {
+ // InternalOXtype.g:4536:5: (lv_writeable_1_0= 'var' )
+ // InternalOXtype.g:4537:6: lv_writeable_1_0= 'var'
+ {
+ lv_writeable_1_0=(Token)match(input,72,FOLLOW_26); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_writeable_1_0, grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXVariableDeclarationRule());
+ }
+ setWithLastConsumed(current, "writeable", true, "var");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:4550:4: otherlv_2= 'val'
+ {
+ otherlv_2=(Token)match(input,73,FOLLOW_26); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:4555:3: ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) )
+ int alt80=2;
+ int LA80_0 = input.LA(1);
+
+ if ( (LA80_0==RULE_ID) ) {
+ int LA80_1 = input.LA(2);
+
+ if ( (synpred35_InternalOXtype()) ) {
+ alt80=1;
+ }
+ else if ( (true) ) {
+ alt80=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 80, 1, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA80_0==20) && (synpred35_InternalOXtype())) {
+ alt80=1;
+ }
+ else if ( (LA80_0==45) && (synpred35_InternalOXtype())) {
+ alt80=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 80, 0, input);
+
+ throw nvae;
+ }
+ switch (alt80) {
+ case 1 :
+ // InternalOXtype.g:4556:4: ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) )
+ {
+ // InternalOXtype.g:4556:4: ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) )
+ // InternalOXtype.g:4557:5: ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) )
+ {
+ // InternalOXtype.g:4570:5: ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) )
+ // InternalOXtype.g:4571:6: ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) )
+ {
+ // InternalOXtype.g:4571:6: ( (lv_type_3_0= ruleJvmTypeReference ) )
+ // InternalOXtype.g:4572:7: (lv_type_3_0= ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:4572:7: (lv_type_3_0= ruleJvmTypeReference )
+ // InternalOXtype.g:4573:8: lv_type_3_0= ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0());
+
+ }
+ pushFollow(FOLLOW_7);
+ lv_type_3_0=ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+ }
+ set(
+ current,
+ "type",
+ lv_type_3_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:4590:6: ( (lv_name_4_0= ruleValidID ) )
+ // InternalOXtype.g:4591:7: (lv_name_4_0= ruleValidID )
+ {
+ // InternalOXtype.g:4591:7: (lv_name_4_0= ruleValidID )
+ // InternalOXtype.g:4592:8: lv_name_4_0= ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0());
+
+ }
+ pushFollow(FOLLOW_68);
+ lv_name_4_0=ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+ }
+ set(
+ current,
+ "name",
+ lv_name_4_0,
+ "org.eclipse.xtext.xbase.Xtype.ValidID");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:4612:4: ( (lv_name_5_0= ruleValidID ) )
+ {
+ // InternalOXtype.g:4612:4: ( (lv_name_5_0= ruleValidID ) )
+ // InternalOXtype.g:4613:5: (lv_name_5_0= ruleValidID )
+ {
+ // InternalOXtype.g:4613:5: (lv_name_5_0= ruleValidID )
+ // InternalOXtype.g:4614:6: lv_name_5_0= ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0());
+
+ }
+ pushFollow(FOLLOW_68);
+ lv_name_5_0=ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+ }
+ set(
+ current,
+ "name",
+ lv_name_5_0,
+ "org.eclipse.xtext.xbase.Xtype.ValidID");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:4632:3: (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )?
+ int alt81=2;
+ int LA81_0 = input.LA(1);
+
+ if ( (LA81_0==23) ) {
+ alt81=1;
+ }
+ switch (alt81) {
+ case 1 :
+ // InternalOXtype.g:4633:4: otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) )
+ {
+ otherlv_6=(Token)match(input,23,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_6, grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0());
+
+ }
+ // InternalOXtype.g:4637:4: ( (lv_right_7_0= ruleXExpression ) )
+ // InternalOXtype.g:4638:5: (lv_right_7_0= ruleXExpression )
+ {
+ // InternalOXtype.g:4638:5: (lv_right_7_0= ruleXExpression )
+ // InternalOXtype.g:4639:6: lv_right_7_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_right_7_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+ }
+ set(
+ current,
+ "right",
+ lv_right_7_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXVariableDeclaration"
+
+
+ // $ANTLR start "entryRuleJvmFormalParameter"
+ // InternalOXtype.g:4661:1: entryRuleJvmFormalParameter returns [EObject current=null] : iv_ruleJvmFormalParameter= ruleJvmFormalParameter EOF ;
+ public final EObject entryRuleJvmFormalParameter() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleJvmFormalParameter = null;
+
+
+ try {
+ // InternalOXtype.g:4661:59: (iv_ruleJvmFormalParameter= ruleJvmFormalParameter EOF )
+ // InternalOXtype.g:4662:2: iv_ruleJvmFormalParameter= ruleJvmFormalParameter EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getJvmFormalParameterRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleJvmFormalParameter=ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleJvmFormalParameter;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleJvmFormalParameter"
+
+
+ // $ANTLR start "ruleJvmFormalParameter"
+ // InternalOXtype.g:4668:1: ruleJvmFormalParameter returns [EObject current=null] : ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) ) ;
+ public final EObject ruleJvmFormalParameter() throws RecognitionException {
+ EObject current = null;
+
+ EObject lv_parameterType_0_0 = null;
+
+ AntlrDatatypeRuleToken lv_name_1_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:4674:2: ( ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) ) )
+ // InternalOXtype.g:4675:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) )
+ {
+ // InternalOXtype.g:4675:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) )
+ // InternalOXtype.g:4676:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) )
+ {
+ // InternalOXtype.g:4676:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) )?
+ int alt82=2;
+ int LA82_0 = input.LA(1);
+
+ if ( (LA82_0==RULE_ID) ) {
+ int LA82_1 = input.LA(2);
+
+ if ( (LA82_1==RULE_ID||LA82_1==25||LA82_1==32||LA82_1==57) ) {
+ alt82=1;
+ }
+ }
+ else if ( (LA82_0==20||LA82_0==45) ) {
+ alt82=1;
+ }
+ switch (alt82) {
+ case 1 :
+ // InternalOXtype.g:4677:4: (lv_parameterType_0_0= ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:4677:4: (lv_parameterType_0_0= ruleJvmTypeReference )
+ // InternalOXtype.g:4678:5: lv_parameterType_0_0= ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_7);
+ lv_parameterType_0_0=ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule());
+ }
+ set(
+ current,
+ "parameterType",
+ lv_parameterType_0_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:4695:3: ( (lv_name_1_0= ruleValidID ) )
+ // InternalOXtype.g:4696:4: (lv_name_1_0= ruleValidID )
+ {
+ // InternalOXtype.g:4696:4: (lv_name_1_0= ruleValidID )
+ // InternalOXtype.g:4697:5: lv_name_1_0= ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_name_1_0=ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule());
+ }
+ set(
+ current,
+ "name",
+ lv_name_1_0,
+ "org.eclipse.xtext.xbase.Xtype.ValidID");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleJvmFormalParameter"
+
+
+ // $ANTLR start "entryRuleFullJvmFormalParameter"
+ // InternalOXtype.g:4718:1: entryRuleFullJvmFormalParameter returns [EObject current=null] : iv_ruleFullJvmFormalParameter= ruleFullJvmFormalParameter EOF ;
+ public final EObject entryRuleFullJvmFormalParameter() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleFullJvmFormalParameter = null;
+
+
+ try {
+ // InternalOXtype.g:4718:63: (iv_ruleFullJvmFormalParameter= ruleFullJvmFormalParameter EOF )
+ // InternalOXtype.g:4719:2: iv_ruleFullJvmFormalParameter= ruleFullJvmFormalParameter EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getFullJvmFormalParameterRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleFullJvmFormalParameter=ruleFullJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleFullJvmFormalParameter;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleFullJvmFormalParameter"
+
+
+ // $ANTLR start "ruleFullJvmFormalParameter"
+ // InternalOXtype.g:4725:1: ruleFullJvmFormalParameter returns [EObject current=null] : ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) ) ;
+ public final EObject ruleFullJvmFormalParameter() throws RecognitionException {
+ EObject current = null;
+
+ EObject lv_parameterType_0_0 = null;
+
+ AntlrDatatypeRuleToken lv_name_1_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:4731:2: ( ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) ) )
+ // InternalOXtype.g:4732:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) )
+ {
+ // InternalOXtype.g:4732:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) )
+ // InternalOXtype.g:4733:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) )
+ {
+ // InternalOXtype.g:4733:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) )
+ // InternalOXtype.g:4734:4: (lv_parameterType_0_0= ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:4734:4: (lv_parameterType_0_0= ruleJvmTypeReference )
+ // InternalOXtype.g:4735:5: lv_parameterType_0_0= ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_7);
+ lv_parameterType_0_0=ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule());
+ }
+ set(
+ current,
+ "parameterType",
+ lv_parameterType_0_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:4752:3: ( (lv_name_1_0= ruleValidID ) )
+ // InternalOXtype.g:4753:4: (lv_name_1_0= ruleValidID )
+ {
+ // InternalOXtype.g:4753:4: (lv_name_1_0= ruleValidID )
+ // InternalOXtype.g:4754:5: lv_name_1_0= ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_name_1_0=ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule());
+ }
+ set(
+ current,
+ "name",
+ lv_name_1_0,
+ "org.eclipse.xtext.xbase.Xtype.ValidID");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleFullJvmFormalParameter"
+
+
+ // $ANTLR start "entryRuleXFeatureCall"
+ // InternalOXtype.g:4775:1: entryRuleXFeatureCall returns [EObject current=null] : iv_ruleXFeatureCall= ruleXFeatureCall EOF ;
+ public final EObject entryRuleXFeatureCall() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXFeatureCall = null;
+
+
+ try {
+ // InternalOXtype.g:4775:53: (iv_ruleXFeatureCall= ruleXFeatureCall EOF )
+ // InternalOXtype.g:4776:2: iv_ruleXFeatureCall= ruleXFeatureCall EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXFeatureCallRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXFeatureCall=ruleXFeatureCall();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXFeatureCall;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXFeatureCall"
+
+
+ // $ANTLR start "ruleXFeatureCall"
+ // InternalOXtype.g:4782:1: ruleXFeatureCall returns [EObject current=null] : ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? ) ;
+ public final EObject ruleXFeatureCall() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_3=null;
+ Token otherlv_5=null;
+ Token lv_explicitOperationCall_7_0=null;
+ Token otherlv_10=null;
+ Token otherlv_12=null;
+ EObject lv_typeArguments_2_0 = null;
+
+ EObject lv_typeArguments_4_0 = null;
+
+ EObject lv_featureCallArguments_8_0 = null;
+
+ EObject lv_featureCallArguments_9_0 = null;
+
+ EObject lv_featureCallArguments_11_0 = null;
+
+ EObject lv_featureCallArguments_13_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:4788:2: ( ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? ) )
+ // InternalOXtype.g:4789:2: ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? )
+ {
+ // InternalOXtype.g:4789:2: ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? )
+ // InternalOXtype.g:4790:3: () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )?
+ {
+ // InternalOXtype.g:4790:3: ()
+ // InternalOXtype.g:4791:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:4797:3: (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )?
+ int alt84=2;
+ int LA84_0 = input.LA(1);
+
+ if ( (LA84_0==32) ) {
+ alt84=1;
+ }
+ switch (alt84) {
+ case 1 :
+ // InternalOXtype.g:4798:4: otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>'
+ {
+ otherlv_1=(Token)match(input,32,FOLLOW_38); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0());
+
+ }
+ // InternalOXtype.g:4802:4: ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:4803:5: (lv_typeArguments_2_0= ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:4803:5: (lv_typeArguments_2_0= ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:4804:6: lv_typeArguments_2_0= ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_39);
+ lv_typeArguments_2_0=ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ current,
+ "typeArguments",
+ lv_typeArguments_2_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:4821:4: (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )*
+ loop83:
+ do {
+ int alt83=2;
+ int LA83_0 = input.LA(1);
+
+ if ( (LA83_0==21) ) {
+ alt83=1;
+ }
+
+
+ switch (alt83) {
+ case 1 :
+ // InternalOXtype.g:4822:5: otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) )
+ {
+ otherlv_3=(Token)match(input,21,FOLLOW_38); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_3, grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0());
+
+ }
+ // InternalOXtype.g:4826:5: ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:4827:6: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:4827:6: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:4828:7: lv_typeArguments_4_0= ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0());
+
+ }
+ pushFollow(FOLLOW_39);
+ lv_typeArguments_4_0=ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ current,
+ "typeArguments",
+ lv_typeArguments_4_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop83;
+ }
+ } while (true);
+
+ otherlv_5=(Token)match(input,33,FOLLOW_37); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_5, grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3());
+
+ }
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:4851:3: ( ( ruleIdOrSuper ) )
+ // InternalOXtype.g:4852:4: ( ruleIdOrSuper )
+ {
+ // InternalOXtype.g:4852:4: ( ruleIdOrSuper )
+ // InternalOXtype.g:4853:5: ruleIdOrSuper
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXFeatureCallRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0());
+
+ }
+ pushFollow(FOLLOW_69);
+ ruleIdOrSuper();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:4867:3: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )?
+ int alt87=2;
+ alt87 = dfa87.predict(input);
+ switch (alt87) {
+ case 1 :
+ // InternalOXtype.g:4868:4: ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')'
+ {
+ // InternalOXtype.g:4868:4: ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) )
+ // InternalOXtype.g:4869:5: ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' )
+ {
+ // InternalOXtype.g:4873:5: (lv_explicitOperationCall_7_0= '(' )
+ // InternalOXtype.g:4874:6: lv_explicitOperationCall_7_0= '('
+ {
+ lv_explicitOperationCall_7_0=(Token)match(input,20,FOLLOW_41); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_explicitOperationCall_7_0, grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXFeatureCallRule());
+ }
+ setWithLastConsumed(current, "explicitOperationCall", true, "(");
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:4886:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )?
+ int alt86=3;
+ alt86 = dfa86.predict(input);
+ switch (alt86) {
+ case 1 :
+ // InternalOXtype.g:4887:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) )
+ {
+ // InternalOXtype.g:4887:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) )
+ // InternalOXtype.g:4888:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure )
+ {
+ // InternalOXtype.g:4913:6: (lv_featureCallArguments_8_0= ruleXShortClosure )
+ // InternalOXtype.g:4914:7: lv_featureCallArguments_8_0= ruleXShortClosure
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0());
+
+ }
+ pushFollow(FOLLOW_11);
+ lv_featureCallArguments_8_0=ruleXShortClosure();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ current,
+ "featureCallArguments",
+ lv_featureCallArguments_8_0,
+ "org.eclipse.xtext.xbase.Xbase.XShortClosure");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:4932:5: ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* )
+ {
+ // InternalOXtype.g:4932:5: ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* )
+ // InternalOXtype.g:4933:6: ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )*
+ {
+ // InternalOXtype.g:4933:6: ( (lv_featureCallArguments_9_0= ruleXExpression ) )
+ // InternalOXtype.g:4934:7: (lv_featureCallArguments_9_0= ruleXExpression )
+ {
+ // InternalOXtype.g:4934:7: (lv_featureCallArguments_9_0= ruleXExpression )
+ // InternalOXtype.g:4935:8: lv_featureCallArguments_9_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0());
+
+ }
+ pushFollow(FOLLOW_10);
+ lv_featureCallArguments_9_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ current,
+ "featureCallArguments",
+ lv_featureCallArguments_9_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:4952:6: (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )*
+ loop85:
+ do {
+ int alt85=2;
+ int LA85_0 = input.LA(1);
+
+ if ( (LA85_0==21) ) {
+ alt85=1;
+ }
+
+
+ switch (alt85) {
+ case 1 :
+ // InternalOXtype.g:4953:7: otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) )
+ {
+ otherlv_10=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_10, grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0());
+
+ }
+ // InternalOXtype.g:4957:7: ( (lv_featureCallArguments_11_0= ruleXExpression ) )
+ // InternalOXtype.g:4958:8: (lv_featureCallArguments_11_0= ruleXExpression )
+ {
+ // InternalOXtype.g:4958:8: (lv_featureCallArguments_11_0= ruleXExpression )
+ // InternalOXtype.g:4959:9: lv_featureCallArguments_11_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_10);
+ lv_featureCallArguments_11_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ current,
+ "featureCallArguments",
+ lv_featureCallArguments_11_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop85;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ otherlv_12=(Token)match(input,22,FOLLOW_70); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_12, grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:4984:3: ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )?
+ int alt88=2;
+ alt88 = dfa88.predict(input);
+ switch (alt88) {
+ case 1 :
+ // InternalOXtype.g:4985:4: ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure )
+ {
+ // InternalOXtype.g:4991:4: (lv_featureCallArguments_13_0= ruleXClosure )
+ // InternalOXtype.g:4992:5: lv_featureCallArguments_13_0= ruleXClosure
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_featureCallArguments_13_0=ruleXClosure();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ current,
+ "featureCallArguments",
+ lv_featureCallArguments_13_0,
+ "org.eclipse.xtext.xbase.Xbase.XClosure");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXFeatureCall"
+
+
+ // $ANTLR start "entryRuleFeatureCallID"
+ // InternalOXtype.g:5013:1: entryRuleFeatureCallID returns [String current=null] : iv_ruleFeatureCallID= ruleFeatureCallID EOF ;
+ public final String entryRuleFeatureCallID() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleFeatureCallID = null;
+
+
+ try {
+ // InternalOXtype.g:5013:53: (iv_ruleFeatureCallID= ruleFeatureCallID EOF )
+ // InternalOXtype.g:5014:2: iv_ruleFeatureCallID= ruleFeatureCallID EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getFeatureCallIDRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleFeatureCallID=ruleFeatureCallID();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleFeatureCallID.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleFeatureCallID"
+
+
+ // $ANTLR start "ruleFeatureCallID"
+ // InternalOXtype.g:5020:1: ruleFeatureCallID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' ) ;
+ public final AntlrDatatypeRuleToken ruleFeatureCallID() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token kw=null;
+ AntlrDatatypeRuleToken this_ValidID_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:5026:2: ( (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' ) )
+ // InternalOXtype.g:5027:2: (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' )
+ {
+ // InternalOXtype.g:5027:2: (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' )
+ int alt89=5;
+ switch ( input.LA(1) ) {
+ case RULE_ID:
+ {
+ alt89=1;
+ }
+ break;
+ case 74:
+ {
+ alt89=2;
+ }
+ break;
+ case 14:
+ {
+ alt89=3;
+ }
+ break;
+ case 13:
+ {
+ alt89=4;
+ }
+ break;
+ case 15:
+ {
+ alt89=5;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 89, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt89) {
+ case 1 :
+ // InternalOXtype.g:5028:3: this_ValidID_0= ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_ValidID_0=ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(this_ValidID_0);
+
+ }
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:5039:3: kw= 'extends'
+ {
+ kw=(Token)match(input,74,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1());
+
+ }
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:5045:3: kw= 'static'
+ {
+ kw=(Token)match(input,14,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2());
+
+ }
+
+ }
+ break;
+ case 4 :
+ // InternalOXtype.g:5051:3: kw= 'import'
+ {
+ kw=(Token)match(input,13,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getImportKeyword_3());
+
+ }
+
+ }
+ break;
+ case 5 :
+ // InternalOXtype.g:5057:3: kw= 'extension'
+ {
+ kw=(Token)match(input,15,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleFeatureCallID"
+
+
+ // $ANTLR start "entryRuleIdOrSuper"
+ // InternalOXtype.g:5066:1: entryRuleIdOrSuper returns [String current=null] : iv_ruleIdOrSuper= ruleIdOrSuper EOF ;
+ public final String entryRuleIdOrSuper() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleIdOrSuper = null;
+
+
+ try {
+ // InternalOXtype.g:5066:49: (iv_ruleIdOrSuper= ruleIdOrSuper EOF )
+ // InternalOXtype.g:5067:2: iv_ruleIdOrSuper= ruleIdOrSuper EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getIdOrSuperRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleIdOrSuper=ruleIdOrSuper();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleIdOrSuper.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleIdOrSuper"
+
+
+ // $ANTLR start "ruleIdOrSuper"
+ // InternalOXtype.g:5073:1: ruleIdOrSuper returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' ) ;
+ public final AntlrDatatypeRuleToken ruleIdOrSuper() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token kw=null;
+ AntlrDatatypeRuleToken this_FeatureCallID_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:5079:2: ( (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' ) )
+ // InternalOXtype.g:5080:2: (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' )
+ {
+ // InternalOXtype.g:5080:2: (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' )
+ int alt90=2;
+ int LA90_0 = input.LA(1);
+
+ if ( (LA90_0==RULE_ID||(LA90_0>=13 && LA90_0<=15)||LA90_0==74) ) {
+ alt90=1;
+ }
+ else if ( (LA90_0==75) ) {
+ alt90=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 90, 0, input);
+
+ throw nvae;
+ }
+ switch (alt90) {
+ case 1 :
+ // InternalOXtype.g:5081:3: this_FeatureCallID_0= ruleFeatureCallID
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_FeatureCallID_0=ruleFeatureCallID();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(this_FeatureCallID_0);
+
+ }
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:5092:3: kw= 'super'
+ {
+ kw=(Token)match(input,75,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getIdOrSuperAccess().getSuperKeyword_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleIdOrSuper"
+
+
+ // $ANTLR start "entryRuleXConstructorCall"
+ // InternalOXtype.g:5101:1: entryRuleXConstructorCall returns [EObject current=null] : iv_ruleXConstructorCall= ruleXConstructorCall EOF ;
+ public final EObject entryRuleXConstructorCall() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXConstructorCall = null;
+
+
+ try {
+ // InternalOXtype.g:5101:57: (iv_ruleXConstructorCall= ruleXConstructorCall EOF )
+ // InternalOXtype.g:5102:2: iv_ruleXConstructorCall= ruleXConstructorCall EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXConstructorCallRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXConstructorCall=ruleXConstructorCall();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXConstructorCall;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXConstructorCall"
+
+
+ // $ANTLR start "ruleXConstructorCall"
+ // InternalOXtype.g:5108:1: ruleXConstructorCall returns [EObject current=null] : ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? ) ;
+ public final EObject ruleXConstructorCall() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_3=null;
+ Token otherlv_5=null;
+ Token otherlv_7=null;
+ Token lv_explicitConstructorCall_8_0=null;
+ Token otherlv_11=null;
+ Token otherlv_13=null;
+ EObject lv_typeArguments_4_0 = null;
+
+ EObject lv_typeArguments_6_0 = null;
+
+ EObject lv_arguments_9_0 = null;
+
+ EObject lv_arguments_10_0 = null;
+
+ EObject lv_arguments_12_0 = null;
+
+ EObject lv_arguments_14_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:5114:2: ( ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? ) )
+ // InternalOXtype.g:5115:2: ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? )
+ {
+ // InternalOXtype.g:5115:2: ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? )
+ // InternalOXtype.g:5116:3: () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )?
+ {
+ // InternalOXtype.g:5116:3: ()
+ // InternalOXtype.g:5117:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,76,FOLLOW_7); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXConstructorCallAccess().getNewKeyword_1());
+
+ }
+ // InternalOXtype.g:5127:3: ( ( ruleQualifiedName ) )
+ // InternalOXtype.g:5128:4: ( ruleQualifiedName )
+ {
+ // InternalOXtype.g:5128:4: ( ruleQualifiedName )
+ // InternalOXtype.g:5129:5: ruleQualifiedName
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXConstructorCallRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0());
+
+ }
+ pushFollow(FOLLOW_71);
+ ruleQualifiedName();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:5143:3: ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )?
+ int alt92=2;
+ alt92 = dfa92.predict(input);
+ switch (alt92) {
+ case 1 :
+ // InternalOXtype.g:5144:4: ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>'
+ {
+ // InternalOXtype.g:5144:4: ( ( '<' )=>otherlv_3= '<' )
+ // InternalOXtype.g:5145:5: ( '<' )=>otherlv_3= '<'
+ {
+ otherlv_3=(Token)match(input,32,FOLLOW_38); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_3, grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0());
+
+ }
+
+ }
+
+ // InternalOXtype.g:5151:4: ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:5152:5: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:5152:5: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:5153:6: lv_typeArguments_4_0= ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0());
+
+ }
+ pushFollow(FOLLOW_39);
+ lv_typeArguments_4_0=ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ current,
+ "typeArguments",
+ lv_typeArguments_4_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:5170:4: (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )*
+ loop91:
+ do {
+ int alt91=2;
+ int LA91_0 = input.LA(1);
+
+ if ( (LA91_0==21) ) {
+ alt91=1;
+ }
+
+
+ switch (alt91) {
+ case 1 :
+ // InternalOXtype.g:5171:5: otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) )
+ {
+ otherlv_5=(Token)match(input,21,FOLLOW_38); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_5, grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0());
+
+ }
+ // InternalOXtype.g:5175:5: ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:5176:6: (lv_typeArguments_6_0= ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:5176:6: (lv_typeArguments_6_0= ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:5177:7: lv_typeArguments_6_0= ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0());
+
+ }
+ pushFollow(FOLLOW_39);
+ lv_typeArguments_6_0=ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ current,
+ "typeArguments",
+ lv_typeArguments_6_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop91;
+ }
+ } while (true);
+
+ otherlv_7=(Token)match(input,33,FOLLOW_69); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_7, grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3());
+
+ }
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:5200:3: ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )?
+ int alt95=2;
+ alt95 = dfa95.predict(input);
+ switch (alt95) {
+ case 1 :
+ // InternalOXtype.g:5201:4: ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')'
+ {
+ // InternalOXtype.g:5201:4: ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) )
+ // InternalOXtype.g:5202:5: ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' )
+ {
+ // InternalOXtype.g:5206:5: (lv_explicitConstructorCall_8_0= '(' )
+ // InternalOXtype.g:5207:6: lv_explicitConstructorCall_8_0= '('
+ {
+ lv_explicitConstructorCall_8_0=(Token)match(input,20,FOLLOW_41); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_explicitConstructorCall_8_0, grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXConstructorCallRule());
+ }
+ setWithLastConsumed(current, "explicitConstructorCall", true, "(");
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:5219:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )?
+ int alt94=3;
+ alt94 = dfa94.predict(input);
+ switch (alt94) {
+ case 1 :
+ // InternalOXtype.g:5220:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) )
+ {
+ // InternalOXtype.g:5220:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) )
+ // InternalOXtype.g:5221:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure )
+ {
+ // InternalOXtype.g:5246:6: (lv_arguments_9_0= ruleXShortClosure )
+ // InternalOXtype.g:5247:7: lv_arguments_9_0= ruleXShortClosure
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0());
+
+ }
+ pushFollow(FOLLOW_11);
+ lv_arguments_9_0=ruleXShortClosure();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ current,
+ "arguments",
+ lv_arguments_9_0,
+ "org.eclipse.xtext.xbase.Xbase.XShortClosure");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:5265:5: ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* )
+ {
+ // InternalOXtype.g:5265:5: ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* )
+ // InternalOXtype.g:5266:6: ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )*
+ {
+ // InternalOXtype.g:5266:6: ( (lv_arguments_10_0= ruleXExpression ) )
+ // InternalOXtype.g:5267:7: (lv_arguments_10_0= ruleXExpression )
+ {
+ // InternalOXtype.g:5267:7: (lv_arguments_10_0= ruleXExpression )
+ // InternalOXtype.g:5268:8: lv_arguments_10_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0());
+
+ }
+ pushFollow(FOLLOW_10);
+ lv_arguments_10_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ current,
+ "arguments",
+ lv_arguments_10_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:5285:6: (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )*
+ loop93:
+ do {
+ int alt93=2;
+ int LA93_0 = input.LA(1);
+
+ if ( (LA93_0==21) ) {
+ alt93=1;
+ }
+
+
+ switch (alt93) {
+ case 1 :
+ // InternalOXtype.g:5286:7: otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) )
+ {
+ otherlv_11=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_11, grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0());
+
+ }
+ // InternalOXtype.g:5290:7: ( (lv_arguments_12_0= ruleXExpression ) )
+ // InternalOXtype.g:5291:8: (lv_arguments_12_0= ruleXExpression )
+ {
+ // InternalOXtype.g:5291:8: (lv_arguments_12_0= ruleXExpression )
+ // InternalOXtype.g:5292:9: lv_arguments_12_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_10);
+ lv_arguments_12_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ current,
+ "arguments",
+ lv_arguments_12_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop93;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ otherlv_13=(Token)match(input,22,FOLLOW_70); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_13, grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:5317:3: ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )?
+ int alt96=2;
+ alt96 = dfa96.predict(input);
+ switch (alt96) {
+ case 1 :
+ // InternalOXtype.g:5318:4: ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure )
+ {
+ // InternalOXtype.g:5324:4: (lv_arguments_14_0= ruleXClosure )
+ // InternalOXtype.g:5325:5: lv_arguments_14_0= ruleXClosure
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_arguments_14_0=ruleXClosure();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ current,
+ "arguments",
+ lv_arguments_14_0,
+ "org.eclipse.xtext.xbase.Xbase.XClosure");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXConstructorCall"
+
+
+ // $ANTLR start "entryRuleXBooleanLiteral"
+ // InternalOXtype.g:5346:1: entryRuleXBooleanLiteral returns [EObject current=null] : iv_ruleXBooleanLiteral= ruleXBooleanLiteral EOF ;
+ public final EObject entryRuleXBooleanLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXBooleanLiteral = null;
+
+
+ try {
+ // InternalOXtype.g:5346:56: (iv_ruleXBooleanLiteral= ruleXBooleanLiteral EOF )
+ // InternalOXtype.g:5347:2: iv_ruleXBooleanLiteral= ruleXBooleanLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXBooleanLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXBooleanLiteral=ruleXBooleanLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXBooleanLiteral;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXBooleanLiteral"
+
+
+ // $ANTLR start "ruleXBooleanLiteral"
+ // InternalOXtype.g:5353:1: ruleXBooleanLiteral returns [EObject current=null] : ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) ;
+ public final EObject ruleXBooleanLiteral() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token lv_isTrue_2_0=null;
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:5359:2: ( ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) )
+ // InternalOXtype.g:5360:2: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) )
+ {
+ // InternalOXtype.g:5360:2: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) )
+ // InternalOXtype.g:5361:3: () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) )
+ {
+ // InternalOXtype.g:5361:3: ()
+ // InternalOXtype.g:5362:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:5368:3: (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) )
+ int alt97=2;
+ int LA97_0 = input.LA(1);
+
+ if ( (LA97_0==77) ) {
+ alt97=1;
+ }
+ else if ( (LA97_0==78) ) {
+ alt97=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 97, 0, input);
+
+ throw nvae;
+ }
+ switch (alt97) {
+ case 1 :
+ // InternalOXtype.g:5369:4: otherlv_1= 'false'
+ {
+ otherlv_1=(Token)match(input,77,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:5374:4: ( (lv_isTrue_2_0= 'true' ) )
+ {
+ // InternalOXtype.g:5374:4: ( (lv_isTrue_2_0= 'true' ) )
+ // InternalOXtype.g:5375:5: (lv_isTrue_2_0= 'true' )
+ {
+ // InternalOXtype.g:5375:5: (lv_isTrue_2_0= 'true' )
+ // InternalOXtype.g:5376:6: lv_isTrue_2_0= 'true'
+ {
+ lv_isTrue_2_0=(Token)match(input,78,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_isTrue_2_0, grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXBooleanLiteralRule());
+ }
+ setWithLastConsumed(current, "isTrue", true, "true");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXBooleanLiteral"
+
+
+ // $ANTLR start "entryRuleXNullLiteral"
+ // InternalOXtype.g:5393:1: entryRuleXNullLiteral returns [EObject current=null] : iv_ruleXNullLiteral= ruleXNullLiteral EOF ;
+ public final EObject entryRuleXNullLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXNullLiteral = null;
+
+
+ try {
+ // InternalOXtype.g:5393:53: (iv_ruleXNullLiteral= ruleXNullLiteral EOF )
+ // InternalOXtype.g:5394:2: iv_ruleXNullLiteral= ruleXNullLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXNullLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXNullLiteral=ruleXNullLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXNullLiteral;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXNullLiteral"
+
+
+ // $ANTLR start "ruleXNullLiteral"
+ // InternalOXtype.g:5400:1: ruleXNullLiteral returns [EObject current=null] : ( () otherlv_1= 'null' ) ;
+ public final EObject ruleXNullLiteral() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:5406:2: ( ( () otherlv_1= 'null' ) )
+ // InternalOXtype.g:5407:2: ( () otherlv_1= 'null' )
+ {
+ // InternalOXtype.g:5407:2: ( () otherlv_1= 'null' )
+ // InternalOXtype.g:5408:3: () otherlv_1= 'null'
+ {
+ // InternalOXtype.g:5408:3: ()
+ // InternalOXtype.g:5409:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,79,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXNullLiteralAccess().getNullKeyword_1());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXNullLiteral"
+
+
+ // $ANTLR start "entryRuleXNumberLiteral"
+ // InternalOXtype.g:5423:1: entryRuleXNumberLiteral returns [EObject current=null] : iv_ruleXNumberLiteral= ruleXNumberLiteral EOF ;
+ public final EObject entryRuleXNumberLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXNumberLiteral = null;
+
+
+ try {
+ // InternalOXtype.g:5423:55: (iv_ruleXNumberLiteral= ruleXNumberLiteral EOF )
+ // InternalOXtype.g:5424:2: iv_ruleXNumberLiteral= ruleXNumberLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXNumberLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXNumberLiteral=ruleXNumberLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXNumberLiteral;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXNumberLiteral"
+
+
+ // $ANTLR start "ruleXNumberLiteral"
+ // InternalOXtype.g:5430:1: ruleXNumberLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= ruleNumber ) ) ) ;
+ public final EObject ruleXNumberLiteral() throws RecognitionException {
+ EObject current = null;
+
+ AntlrDatatypeRuleToken lv_value_1_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:5436:2: ( ( () ( (lv_value_1_0= ruleNumber ) ) ) )
+ // InternalOXtype.g:5437:2: ( () ( (lv_value_1_0= ruleNumber ) ) )
+ {
+ // InternalOXtype.g:5437:2: ( () ( (lv_value_1_0= ruleNumber ) ) )
+ // InternalOXtype.g:5438:3: () ( (lv_value_1_0= ruleNumber ) )
+ {
+ // InternalOXtype.g:5438:3: ()
+ // InternalOXtype.g:5439:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:5445:3: ( (lv_value_1_0= ruleNumber ) )
+ // InternalOXtype.g:5446:4: (lv_value_1_0= ruleNumber )
+ {
+ // InternalOXtype.g:5446:4: (lv_value_1_0= ruleNumber )
+ // InternalOXtype.g:5447:5: lv_value_1_0= ruleNumber
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_value_1_0=ruleNumber();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXNumberLiteralRule());
+ }
+ set(
+ current,
+ "value",
+ lv_value_1_0,
+ "org.eclipse.xtext.xbase.Xbase.Number");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXNumberLiteral"
+
+
+ // $ANTLR start "entryRuleXStringLiteral"
+ // InternalOXtype.g:5468:1: entryRuleXStringLiteral returns [EObject current=null] : iv_ruleXStringLiteral= ruleXStringLiteral EOF ;
+ public final EObject entryRuleXStringLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXStringLiteral = null;
+
+
+ try {
+ // InternalOXtype.g:5468:55: (iv_ruleXStringLiteral= ruleXStringLiteral EOF )
+ // InternalOXtype.g:5469:2: iv_ruleXStringLiteral= ruleXStringLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXStringLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXStringLiteral=ruleXStringLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXStringLiteral;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXStringLiteral"
+
+
+ // $ANTLR start "ruleXStringLiteral"
+ // InternalOXtype.g:5475:1: ruleXStringLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= RULE_STRING ) ) ) ;
+ public final EObject ruleXStringLiteral() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_value_1_0=null;
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:5481:2: ( ( () ( (lv_value_1_0= RULE_STRING ) ) ) )
+ // InternalOXtype.g:5482:2: ( () ( (lv_value_1_0= RULE_STRING ) ) )
+ {
+ // InternalOXtype.g:5482:2: ( () ( (lv_value_1_0= RULE_STRING ) ) )
+ // InternalOXtype.g:5483:3: () ( (lv_value_1_0= RULE_STRING ) )
+ {
+ // InternalOXtype.g:5483:3: ()
+ // InternalOXtype.g:5484:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0(),
+ current);
+
+ }
+
+ }
+
+ // InternalOXtype.g:5490:3: ( (lv_value_1_0= RULE_STRING ) )
+ // InternalOXtype.g:5491:4: (lv_value_1_0= RULE_STRING )
+ {
+ // InternalOXtype.g:5491:4: (lv_value_1_0= RULE_STRING )
+ // InternalOXtype.g:5492:5: lv_value_1_0= RULE_STRING
+ {
+ lv_value_1_0=(Token)match(input,RULE_STRING,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_value_1_0, grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXStringLiteralRule());
+ }
+ setWithLastConsumed(
+ current,
+ "value",
+ lv_value_1_0,
+ "org.eclipse.xtext.xbase.Xtype.STRING");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXStringLiteral"
+
+
+ // $ANTLR start "entryRuleXTypeLiteral"
+ // InternalOXtype.g:5512:1: entryRuleXTypeLiteral returns [EObject current=null] : iv_ruleXTypeLiteral= ruleXTypeLiteral EOF ;
+ public final EObject entryRuleXTypeLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXTypeLiteral = null;
+
+
+ try {
+ // InternalOXtype.g:5512:53: (iv_ruleXTypeLiteral= ruleXTypeLiteral EOF )
+ // InternalOXtype.g:5513:2: iv_ruleXTypeLiteral= ruleXTypeLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXTypeLiteralRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXTypeLiteral=ruleXTypeLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXTypeLiteral;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXTypeLiteral"
+
+
+ // $ANTLR start "ruleXTypeLiteral"
+ // InternalOXtype.g:5519:1: ruleXTypeLiteral returns [EObject current=null] : ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' ) ;
+ public final EObject ruleXTypeLiteral() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_2=null;
+ Token otherlv_5=null;
+ AntlrDatatypeRuleToken lv_arrayDimensions_4_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:5525:2: ( ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' ) )
+ // InternalOXtype.g:5526:2: ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' )
+ {
+ // InternalOXtype.g:5526:2: ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' )
+ // InternalOXtype.g:5527:3: () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')'
+ {
+ // InternalOXtype.g:5527:3: ()
+ // InternalOXtype.g:5528:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,80,FOLLOW_52); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1());
+
+ }
+ otherlv_2=(Token)match(input,20,FOLLOW_7); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2());
+
+ }
+ // InternalOXtype.g:5542:3: ( ( ruleQualifiedName ) )
+ // InternalOXtype.g:5543:4: ( ruleQualifiedName )
+ {
+ // InternalOXtype.g:5543:4: ( ruleQualifiedName )
+ // InternalOXtype.g:5544:5: ruleQualifiedName
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXTypeLiteralRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0());
+
+ }
+ pushFollow(FOLLOW_72);
+ ruleQualifiedName();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:5558:3: ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )*
+ loop98:
+ do {
+ int alt98=2;
+ int LA98_0 = input.LA(1);
+
+ if ( (LA98_0==25) ) {
+ alt98=1;
+ }
+
+
+ switch (alt98) {
+ case 1 :
+ // InternalOXtype.g:5559:4: (lv_arrayDimensions_4_0= ruleArrayBrackets )
+ {
+ // InternalOXtype.g:5559:4: (lv_arrayDimensions_4_0= ruleArrayBrackets )
+ // InternalOXtype.g:5560:5: lv_arrayDimensions_4_0= ruleArrayBrackets
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0());
+
+ }
+ pushFollow(FOLLOW_72);
+ lv_arrayDimensions_4_0=ruleArrayBrackets();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXTypeLiteralRule());
+ }
+ add(
+ current,
+ "arrayDimensions",
+ lv_arrayDimensions_4_0,
+ "org.eclipse.xtext.xbase.Xtype.ArrayBrackets");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop98;
+ }
+ } while (true);
+
+ otherlv_5=(Token)match(input,22,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_5, grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXTypeLiteral"
+
+
+ // $ANTLR start "entryRuleXThrowExpression"
+ // InternalOXtype.g:5585:1: entryRuleXThrowExpression returns [EObject current=null] : iv_ruleXThrowExpression= ruleXThrowExpression EOF ;
+ public final EObject entryRuleXThrowExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXThrowExpression = null;
+
+
+ try {
+ // InternalOXtype.g:5585:57: (iv_ruleXThrowExpression= ruleXThrowExpression EOF )
+ // InternalOXtype.g:5586:2: iv_ruleXThrowExpression= ruleXThrowExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXThrowExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXThrowExpression=ruleXThrowExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXThrowExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXThrowExpression"
+
+
+ // $ANTLR start "ruleXThrowExpression"
+ // InternalOXtype.g:5592:1: ruleXThrowExpression returns [EObject current=null] : ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) ) ;
+ public final EObject ruleXThrowExpression() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ EObject lv_expression_2_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:5598:2: ( ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) ) )
+ // InternalOXtype.g:5599:2: ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) )
+ {
+ // InternalOXtype.g:5599:2: ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) )
+ // InternalOXtype.g:5600:3: () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) )
+ {
+ // InternalOXtype.g:5600:3: ()
+ // InternalOXtype.g:5601:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,81,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1());
+
+ }
+ // InternalOXtype.g:5611:3: ( (lv_expression_2_0= ruleXExpression ) )
+ // InternalOXtype.g:5612:4: (lv_expression_2_0= ruleXExpression )
+ {
+ // InternalOXtype.g:5612:4: (lv_expression_2_0= ruleXExpression )
+ // InternalOXtype.g:5613:5: lv_expression_2_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_expression_2_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXThrowExpressionRule());
+ }
+ set(
+ current,
+ "expression",
+ lv_expression_2_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXThrowExpression"
+
+
+ // $ANTLR start "entryRuleXReturnExpression"
+ // InternalOXtype.g:5634:1: entryRuleXReturnExpression returns [EObject current=null] : iv_ruleXReturnExpression= ruleXReturnExpression EOF ;
+ public final EObject entryRuleXReturnExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXReturnExpression = null;
+
+
+ try {
+ // InternalOXtype.g:5634:58: (iv_ruleXReturnExpression= ruleXReturnExpression EOF )
+ // InternalOXtype.g:5635:2: iv_ruleXReturnExpression= ruleXReturnExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXReturnExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXReturnExpression=ruleXReturnExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXReturnExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXReturnExpression"
+
+
+ // $ANTLR start "ruleXReturnExpression"
+ // InternalOXtype.g:5641:1: ruleXReturnExpression returns [EObject current=null] : ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? ) ;
+ public final EObject ruleXReturnExpression() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ EObject lv_expression_2_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:5647:2: ( ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? ) )
+ // InternalOXtype.g:5648:2: ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? )
+ {
+ // InternalOXtype.g:5648:2: ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? )
+ // InternalOXtype.g:5649:3: () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )?
+ {
+ // InternalOXtype.g:5649:3: ()
+ // InternalOXtype.g:5650:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,82,FOLLOW_73); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1());
+
+ }
+ // InternalOXtype.g:5660:3: ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )?
+ int alt99=2;
+ alt99 = dfa99.predict(input);
+ switch (alt99) {
+ case 1 :
+ // InternalOXtype.g:5661:4: ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression )
+ {
+ // InternalOXtype.g:5662:4: (lv_expression_2_0= ruleXExpression )
+ // InternalOXtype.g:5663:5: lv_expression_2_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_expression_2_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXReturnExpressionRule());
+ }
+ set(
+ current,
+ "expression",
+ lv_expression_2_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXReturnExpression"
+
+
+ // $ANTLR start "entryRuleXTryCatchFinallyExpression"
+ // InternalOXtype.g:5684:1: entryRuleXTryCatchFinallyExpression returns [EObject current=null] : iv_ruleXTryCatchFinallyExpression= ruleXTryCatchFinallyExpression EOF ;
+ public final EObject entryRuleXTryCatchFinallyExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXTryCatchFinallyExpression = null;
+
+
+ try {
+ // InternalOXtype.g:5684:67: (iv_ruleXTryCatchFinallyExpression= ruleXTryCatchFinallyExpression EOF )
+ // InternalOXtype.g:5685:2: iv_ruleXTryCatchFinallyExpression= ruleXTryCatchFinallyExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXTryCatchFinallyExpression=ruleXTryCatchFinallyExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXTryCatchFinallyExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXTryCatchFinallyExpression"
+
+
+ // $ANTLR start "ruleXTryCatchFinallyExpression"
+ // InternalOXtype.g:5691:1: ruleXTryCatchFinallyExpression returns [EObject current=null] : ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) ) ;
+ public final EObject ruleXTryCatchFinallyExpression() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_4=null;
+ Token otherlv_6=null;
+ EObject lv_expression_2_0 = null;
+
+ EObject lv_catchClauses_3_0 = null;
+
+ EObject lv_finallyExpression_5_0 = null;
+
+ EObject lv_finallyExpression_7_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:5697:2: ( ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) ) )
+ // InternalOXtype.g:5698:2: ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) )
+ {
+ // InternalOXtype.g:5698:2: ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) )
+ // InternalOXtype.g:5699:3: () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) )
+ {
+ // InternalOXtype.g:5699:3: ()
+ // InternalOXtype.g:5700:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,83,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1());
+
+ }
+ // InternalOXtype.g:5710:3: ( (lv_expression_2_0= ruleXExpression ) )
+ // InternalOXtype.g:5711:4: (lv_expression_2_0= ruleXExpression )
+ {
+ // InternalOXtype.g:5711:4: (lv_expression_2_0= ruleXExpression )
+ // InternalOXtype.g:5712:5: lv_expression_2_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_74);
+ lv_expression_2_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule());
+ }
+ set(
+ current,
+ "expression",
+ lv_expression_2_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:5729:3: ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) )
+ int alt102=2;
+ int LA102_0 = input.LA(1);
+
+ if ( (LA102_0==86) ) {
+ alt102=1;
+ }
+ else if ( (LA102_0==84) ) {
+ alt102=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 102, 0, input);
+
+ throw nvae;
+ }
+ switch (alt102) {
+ case 1 :
+ // InternalOXtype.g:5730:4: ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? )
+ {
+ // InternalOXtype.g:5730:4: ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? )
+ // InternalOXtype.g:5731:5: ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )?
+ {
+ // InternalOXtype.g:5731:5: ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+
+ int cnt100=0;
+ loop100:
+ do {
+ int alt100=2;
+ int LA100_0 = input.LA(1);
+
+ if ( (LA100_0==86) ) {
+ int LA100_2 = input.LA(2);
+
+ if ( (synpred44_InternalOXtype()) ) {
+ alt100=1;
+ }
+
+
+ }
+
+
+ switch (alt100) {
+ case 1 :
+ // InternalOXtype.g:5732:6: ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause )
+ {
+ // InternalOXtype.g:5733:6: (lv_catchClauses_3_0= ruleXCatchClause )
+ // InternalOXtype.g:5734:7: lv_catchClauses_3_0= ruleXCatchClause
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0());
+
+ }
+ pushFollow(FOLLOW_75);
+ lv_catchClauses_3_0=ruleXCatchClause();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule());
+ }
+ add(
+ current,
+ "catchClauses",
+ lv_catchClauses_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XCatchClause");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ if ( cnt100 >= 1 ) break loop100;
+ if (state.backtracking>0) {state.failed=true; return current;}
+ EarlyExitException eee =
+ new EarlyExitException(100, input);
+ throw eee;
+ }
+ cnt100++;
+ } while (true);
+
+ // InternalOXtype.g:5751:5: ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )?
+ int alt101=2;
+ int LA101_0 = input.LA(1);
+
+ if ( (LA101_0==84) ) {
+ int LA101_1 = input.LA(2);
+
+ if ( (synpred45_InternalOXtype()) ) {
+ alt101=1;
+ }
+ }
+ switch (alt101) {
+ case 1 :
+ // InternalOXtype.g:5752:6: ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) )
+ {
+ // InternalOXtype.g:5752:6: ( ( 'finally' )=>otherlv_4= 'finally' )
+ // InternalOXtype.g:5753:7: ( 'finally' )=>otherlv_4= 'finally'
+ {
+ otherlv_4=(Token)match(input,84,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_4, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0());
+
+ }
+
+ }
+
+ // InternalOXtype.g:5759:6: ( (lv_finallyExpression_5_0= ruleXExpression ) )
+ // InternalOXtype.g:5760:7: (lv_finallyExpression_5_0= ruleXExpression )
+ {
+ // InternalOXtype.g:5760:7: (lv_finallyExpression_5_0= ruleXExpression )
+ // InternalOXtype.g:5761:8: lv_finallyExpression_5_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_finallyExpression_5_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule());
+ }
+ set(
+ current,
+ "finallyExpression",
+ lv_finallyExpression_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:5781:4: (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) )
+ {
+ // InternalOXtype.g:5781:4: (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) )
+ // InternalOXtype.g:5782:5: otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) )
+ {
+ otherlv_6=(Token)match(input,84,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_6, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0());
+
+ }
+ // InternalOXtype.g:5786:5: ( (lv_finallyExpression_7_0= ruleXExpression ) )
+ // InternalOXtype.g:5787:6: (lv_finallyExpression_7_0= ruleXExpression )
+ {
+ // InternalOXtype.g:5787:6: (lv_finallyExpression_7_0= ruleXExpression )
+ // InternalOXtype.g:5788:7: lv_finallyExpression_7_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_finallyExpression_7_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule());
+ }
+ set(
+ current,
+ "finallyExpression",
+ lv_finallyExpression_7_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXTryCatchFinallyExpression"
+
+
+ // $ANTLR start "entryRuleXSynchronizedExpression"
+ // InternalOXtype.g:5811:1: entryRuleXSynchronizedExpression returns [EObject current=null] : iv_ruleXSynchronizedExpression= ruleXSynchronizedExpression EOF ;
+ public final EObject entryRuleXSynchronizedExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXSynchronizedExpression = null;
+
+
+ try {
+ // InternalOXtype.g:5811:64: (iv_ruleXSynchronizedExpression= ruleXSynchronizedExpression EOF )
+ // InternalOXtype.g:5812:2: iv_ruleXSynchronizedExpression= ruleXSynchronizedExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXSynchronizedExpressionRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXSynchronizedExpression=ruleXSynchronizedExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXSynchronizedExpression;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXSynchronizedExpression"
+
+
+ // $ANTLR start "ruleXSynchronizedExpression"
+ // InternalOXtype.g:5818:1: ruleXSynchronizedExpression returns [EObject current=null] : ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) ) ;
+ public final EObject ruleXSynchronizedExpression() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_2=null;
+ Token otherlv_4=null;
+ EObject lv_param_3_0 = null;
+
+ EObject lv_expression_5_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:5824:2: ( ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) ) )
+ // InternalOXtype.g:5825:2: ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) )
+ {
+ // InternalOXtype.g:5825:2: ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) )
+ // InternalOXtype.g:5826:3: ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) )
+ {
+ // InternalOXtype.g:5826:3: ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) )
+ // InternalOXtype.g:5827:4: ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' )
+ {
+ // InternalOXtype.g:5834:4: ( () otherlv_1= 'synchronized' otherlv_2= '(' )
+ // InternalOXtype.g:5835:5: () otherlv_1= 'synchronized' otherlv_2= '('
+ {
+ // InternalOXtype.g:5835:5: ()
+ // InternalOXtype.g:5836:6:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,85,FOLLOW_52); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1());
+
+ }
+ otherlv_2=(Token)match(input,20,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2());
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:5852:3: ( (lv_param_3_0= ruleXExpression ) )
+ // InternalOXtype.g:5853:4: (lv_param_3_0= ruleXExpression )
+ {
+ // InternalOXtype.g:5853:4: (lv_param_3_0= ruleXExpression )
+ // InternalOXtype.g:5854:5: lv_param_3_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_11);
+ lv_param_3_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule());
+ }
+ set(
+ current,
+ "param",
+ lv_param_3_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ otherlv_4=(Token)match(input,22,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_4, grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2());
+
+ }
+ // InternalOXtype.g:5875:3: ( (lv_expression_5_0= ruleXExpression ) )
+ // InternalOXtype.g:5876:4: (lv_expression_5_0= ruleXExpression )
+ {
+ // InternalOXtype.g:5876:4: (lv_expression_5_0= ruleXExpression )
+ // InternalOXtype.g:5877:5: lv_expression_5_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_expression_5_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule());
+ }
+ set(
+ current,
+ "expression",
+ lv_expression_5_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXSynchronizedExpression"
+
+
+ // $ANTLR start "entryRuleXCatchClause"
+ // InternalOXtype.g:5898:1: entryRuleXCatchClause returns [EObject current=null] : iv_ruleXCatchClause= ruleXCatchClause EOF ;
+ public final EObject entryRuleXCatchClause() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXCatchClause = null;
+
+
+ try {
+ // InternalOXtype.g:5898:53: (iv_ruleXCatchClause= ruleXCatchClause EOF )
+ // InternalOXtype.g:5899:2: iv_ruleXCatchClause= ruleXCatchClause EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXCatchClauseRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXCatchClause=ruleXCatchClause();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXCatchClause;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXCatchClause"
+
+
+ // $ANTLR start "ruleXCatchClause"
+ // InternalOXtype.g:5905:1: ruleXCatchClause returns [EObject current=null] : ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) ) ;
+ public final EObject ruleXCatchClause() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+ Token otherlv_1=null;
+ Token otherlv_3=null;
+ EObject lv_declaredParam_2_0 = null;
+
+ EObject lv_expression_4_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:5911:2: ( ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) ) )
+ // InternalOXtype.g:5912:2: ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) )
+ {
+ // InternalOXtype.g:5912:2: ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) )
+ // InternalOXtype.g:5913:3: ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) )
+ {
+ // InternalOXtype.g:5913:3: ( ( 'catch' )=>otherlv_0= 'catch' )
+ // InternalOXtype.g:5914:4: ( 'catch' )=>otherlv_0= 'catch'
+ {
+ otherlv_0=(Token)match(input,86,FOLLOW_52); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_0, grammarAccess.getXCatchClauseAccess().getCatchKeyword_0());
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,20,FOLLOW_26); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1());
+
+ }
+ // InternalOXtype.g:5924:3: ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) )
+ // InternalOXtype.g:5925:4: (lv_declaredParam_2_0= ruleFullJvmFormalParameter )
+ {
+ // InternalOXtype.g:5925:4: (lv_declaredParam_2_0= ruleFullJvmFormalParameter )
+ // InternalOXtype.g:5926:5: lv_declaredParam_2_0= ruleFullJvmFormalParameter
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_11);
+ lv_declaredParam_2_0=ruleFullJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXCatchClauseRule());
+ }
+ set(
+ current,
+ "declaredParam",
+ lv_declaredParam_2_0,
+ "org.eclipse.xtext.xbase.Xbase.FullJvmFormalParameter");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ otherlv_3=(Token)match(input,22,FOLLOW_13); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_3, grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3());
+
+ }
+ // InternalOXtype.g:5947:3: ( (lv_expression_4_0= ruleXExpression ) )
+ // InternalOXtype.g:5948:4: (lv_expression_4_0= ruleXExpression )
+ {
+ // InternalOXtype.g:5948:4: (lv_expression_4_0= ruleXExpression )
+ // InternalOXtype.g:5949:5: lv_expression_4_0= ruleXExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_expression_4_0=ruleXExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXCatchClauseRule());
+ }
+ set(
+ current,
+ "expression",
+ lv_expression_4_0,
+ "org.eclipse.xtext.xbase.Xbase.XExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXCatchClause"
+
+
+ // $ANTLR start "entryRuleQualifiedName"
+ // InternalOXtype.g:5970:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ;
+ public final String entryRuleQualifiedName() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleQualifiedName = null;
+
+
+ try {
+ // InternalOXtype.g:5970:53: (iv_ruleQualifiedName= ruleQualifiedName EOF )
+ // InternalOXtype.g:5971:2: iv_ruleQualifiedName= ruleQualifiedName EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getQualifiedNameRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleQualifiedName=ruleQualifiedName();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleQualifiedName.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleQualifiedName"
+
+
+ // $ANTLR start "ruleQualifiedName"
+ // InternalOXtype.g:5977:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* ) ;
+ public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token kw=null;
+ AntlrDatatypeRuleToken this_ValidID_0 = null;
+
+ AntlrDatatypeRuleToken this_ValidID_2 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:5983:2: ( (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* ) )
+ // InternalOXtype.g:5984:2: (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* )
+ {
+ // InternalOXtype.g:5984:2: (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* )
+ // InternalOXtype.g:5985:3: this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_76);
+ this_ValidID_0=ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(this_ValidID_0);
+
+ }
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+ // InternalOXtype.g:5995:3: ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )*
+ loop103:
+ do {
+ int alt103=2;
+ int LA103_0 = input.LA(1);
+
+ if ( (LA103_0==57) ) {
+ int LA103_2 = input.LA(2);
+
+ if ( (LA103_2==RULE_ID) ) {
+ int LA103_3 = input.LA(3);
+
+ if ( (synpred48_InternalOXtype()) ) {
+ alt103=1;
+ }
+
+
+ }
+
+
+ }
+
+
+ switch (alt103) {
+ case 1 :
+ // InternalOXtype.g:5996:4: ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID
+ {
+ // InternalOXtype.g:5996:4: ( ( '.' )=>kw= '.' )
+ // InternalOXtype.g:5997:5: ( '.' )=>kw= '.'
+ {
+ kw=(Token)match(input,57,FOLLOW_7); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0());
+
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1());
+
+ }
+ pushFollow(FOLLOW_76);
+ this_ValidID_2=ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(this_ValidID_2);
+
+ }
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ default :
+ break loop103;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleQualifiedName"
+
+
+ // $ANTLR start "entryRuleNumber"
+ // InternalOXtype.g:6019:1: entryRuleNumber returns [String current=null] : iv_ruleNumber= ruleNumber EOF ;
+ public final String entryRuleNumber() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleNumber = null;
+
+
+
+ HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+
+ try {
+ // InternalOXtype.g:6021:2: (iv_ruleNumber= ruleNumber EOF )
+ // InternalOXtype.g:6022:2: iv_ruleNumber= ruleNumber EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getNumberRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleNumber=ruleNumber();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleNumber.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+
+ myHiddenTokenState.restore();
+
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleNumber"
+
+
+ // $ANTLR start "ruleNumber"
+ // InternalOXtype.g:6031:1: ruleNumber returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) ) ;
+ public final AntlrDatatypeRuleToken ruleNumber() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token this_HEX_0=null;
+ Token this_INT_1=null;
+ Token this_DECIMAL_2=null;
+ Token kw=null;
+ Token this_INT_4=null;
+ Token this_DECIMAL_5=null;
+
+
+ enterRule();
+ HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+
+ try {
+ // InternalOXtype.g:6038:2: ( (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) ) )
+ // InternalOXtype.g:6039:2: (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) )
+ {
+ // InternalOXtype.g:6039:2: (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) )
+ int alt107=2;
+ int LA107_0 = input.LA(1);
+
+ if ( (LA107_0==RULE_HEX) ) {
+ alt107=1;
+ }
+ else if ( ((LA107_0>=RULE_INT && LA107_0<=RULE_DECIMAL)) ) {
+ alt107=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 107, 0, input);
+
+ throw nvae;
+ }
+ switch (alt107) {
+ case 1 :
+ // InternalOXtype.g:6040:3: this_HEX_0= RULE_HEX
+ {
+ this_HEX_0=(Token)match(input,RULE_HEX,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(this_HEX_0);
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_HEX_0, grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:6048:3: ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? )
+ {
+ // InternalOXtype.g:6048:3: ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? )
+ // InternalOXtype.g:6049:4: (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )?
+ {
+ // InternalOXtype.g:6049:4: (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL )
+ int alt104=2;
+ int LA104_0 = input.LA(1);
+
+ if ( (LA104_0==RULE_INT) ) {
+ alt104=1;
+ }
+ else if ( (LA104_0==RULE_DECIMAL) ) {
+ alt104=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 104, 0, input);
+
+ throw nvae;
+ }
+ switch (alt104) {
+ case 1 :
+ // InternalOXtype.g:6050:5: this_INT_1= RULE_INT
+ {
+ this_INT_1=(Token)match(input,RULE_INT,FOLLOW_76); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(this_INT_1);
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INT_1, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:6058:5: this_DECIMAL_2= RULE_DECIMAL
+ {
+ this_DECIMAL_2=(Token)match(input,RULE_DECIMAL,FOLLOW_76); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(this_DECIMAL_2);
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_DECIMAL_2, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:6066:4: (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )?
+ int alt106=2;
+ int LA106_0 = input.LA(1);
+
+ if ( (LA106_0==57) ) {
+ int LA106_1 = input.LA(2);
+
+ if ( ((LA106_1>=RULE_INT && LA106_1<=RULE_DECIMAL)) ) {
+ alt106=1;
+ }
+ }
+ switch (alt106) {
+ case 1 :
+ // InternalOXtype.g:6067:5: kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL )
+ {
+ kw=(Token)match(input,57,FOLLOW_77); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0());
+
+ }
+ // InternalOXtype.g:6072:5: (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL )
+ int alt105=2;
+ int LA105_0 = input.LA(1);
+
+ if ( (LA105_0==RULE_INT) ) {
+ alt105=1;
+ }
+ else if ( (LA105_0==RULE_DECIMAL) ) {
+ alt105=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 105, 0, input);
+
+ throw nvae;
+ }
+ switch (alt105) {
+ case 1 :
+ // InternalOXtype.g:6073:6: this_INT_4= RULE_INT
+ {
+ this_INT_4=(Token)match(input,RULE_INT,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(this_INT_4);
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INT_4, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:6081:6: this_DECIMAL_5= RULE_DECIMAL
+ {
+ this_DECIMAL_5=(Token)match(input,RULE_DECIMAL,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(this_DECIMAL_5);
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_DECIMAL_5, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+
+ myHiddenTokenState.restore();
+
+ }
+ return current;
+ }
+ // $ANTLR end "ruleNumber"
+
+
+ // $ANTLR start "entryRuleJvmTypeReference"
+ // InternalOXtype.g:6098:1: entryRuleJvmTypeReference returns [EObject current=null] : iv_ruleJvmTypeReference= ruleJvmTypeReference EOF ;
+ public final EObject entryRuleJvmTypeReference() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleJvmTypeReference = null;
+
+
+ try {
+ // InternalOXtype.g:6098:57: (iv_ruleJvmTypeReference= ruleJvmTypeReference EOF )
+ // InternalOXtype.g:6099:2: iv_ruleJvmTypeReference= ruleJvmTypeReference EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getJvmTypeReferenceRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleJvmTypeReference=ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleJvmTypeReference;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleJvmTypeReference"
+
+
+ // $ANTLR start "ruleJvmTypeReference"
+ // InternalOXtype.g:6105:1: ruleJvmTypeReference returns [EObject current=null] : ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) ;
+ public final EObject ruleJvmTypeReference() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_JvmParameterizedTypeReference_0 = null;
+
+ EObject this_XFunctionTypeRef_3 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:6111:2: ( ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) )
+ // InternalOXtype.g:6112:2: ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef )
+ {
+ // InternalOXtype.g:6112:2: ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef )
+ int alt109=2;
+ int LA109_0 = input.LA(1);
+
+ if ( (LA109_0==RULE_ID) ) {
+ alt109=1;
+ }
+ else if ( (LA109_0==20||LA109_0==45) ) {
+ alt109=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 109, 0, input);
+
+ throw nvae;
+ }
+ switch (alt109) {
+ case 1 :
+ // InternalOXtype.g:6113:3: (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* )
+ {
+ // InternalOXtype.g:6113:3: (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* )
+ // InternalOXtype.g:6114:4: this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_70);
+ this_JvmParameterizedTypeReference_0=ruleJvmParameterizedTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_JvmParameterizedTypeReference_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // InternalOXtype.g:6122:4: ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )*
+ loop108:
+ do {
+ int alt108=2;
+ int LA108_0 = input.LA(1);
+
+ if ( (LA108_0==25) ) {
+ int LA108_2 = input.LA(2);
+
+ if ( (LA108_2==26) ) {
+ int LA108_3 = input.LA(3);
+
+ if ( (synpred49_InternalOXtype()) ) {
+ alt108=1;
+ }
+
+
+ }
+
+
+ }
+
+
+ switch (alt108) {
+ case 1 :
+ // InternalOXtype.g:6123:5: ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets )
+ {
+ // InternalOXtype.g:6129:5: ( () ruleArrayBrackets )
+ // InternalOXtype.g:6130:6: () ruleArrayBrackets
+ {
+ // InternalOXtype.g:6130:6: ()
+ // InternalOXtype.g:6131:7:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0(),
+ current);
+
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1());
+
+ }
+ pushFollow(FOLLOW_70);
+ ruleArrayBrackets();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop108;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:6148:3: this_XFunctionTypeRef_3= ruleXFunctionTypeRef
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_XFunctionTypeRef_3=ruleXFunctionTypeRef();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_XFunctionTypeRef_3;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleJvmTypeReference"
+
+
+ // $ANTLR start "entryRuleArrayBrackets"
+ // InternalOXtype.g:6160:1: entryRuleArrayBrackets returns [String current=null] : iv_ruleArrayBrackets= ruleArrayBrackets EOF ;
+ public final String entryRuleArrayBrackets() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleArrayBrackets = null;
+
+
+ try {
+ // InternalOXtype.g:6160:53: (iv_ruleArrayBrackets= ruleArrayBrackets EOF )
+ // InternalOXtype.g:6161:2: iv_ruleArrayBrackets= ruleArrayBrackets EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getArrayBracketsRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleArrayBrackets=ruleArrayBrackets();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleArrayBrackets.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleArrayBrackets"
+
+
+ // $ANTLR start "ruleArrayBrackets"
+ // InternalOXtype.g:6167:1: ruleArrayBrackets returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '[' kw= ']' ) ;
+ public final AntlrDatatypeRuleToken ruleArrayBrackets() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token kw=null;
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:6173:2: ( (kw= '[' kw= ']' ) )
+ // InternalOXtype.g:6174:2: (kw= '[' kw= ']' )
+ {
+ // InternalOXtype.g:6174:2: (kw= '[' kw= ']' )
+ // InternalOXtype.g:6175:3: kw= '[' kw= ']'
+ {
+ kw=(Token)match(input,25,FOLLOW_49); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0());
+
+ }
+ kw=(Token)match(input,26,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleArrayBrackets"
+
+
+ // $ANTLR start "entryRuleXFunctionTypeRef"
+ // InternalOXtype.g:6189:1: entryRuleXFunctionTypeRef returns [EObject current=null] : iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF ;
+ public final EObject entryRuleXFunctionTypeRef() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleXFunctionTypeRef = null;
+
+
+ try {
+ // InternalOXtype.g:6189:57: (iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF )
+ // InternalOXtype.g:6190:2: iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXFunctionTypeRefRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleXFunctionTypeRef=ruleXFunctionTypeRef();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXFunctionTypeRef;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXFunctionTypeRef"
+
+
+ // $ANTLR start "ruleXFunctionTypeRef"
+ // InternalOXtype.g:6196:1: ruleXFunctionTypeRef returns [EObject current=null] : ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) ;
+ public final EObject ruleXFunctionTypeRef() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+ Token otherlv_2=null;
+ Token otherlv_4=null;
+ Token otherlv_5=null;
+ EObject lv_paramTypes_1_0 = null;
+
+ EObject lv_paramTypes_3_0 = null;
+
+ EObject lv_returnType_6_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:6202:2: ( ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) )
+ // InternalOXtype.g:6203:2: ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) )
+ {
+ // InternalOXtype.g:6203:2: ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) )
+ // InternalOXtype.g:6204:3: (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) )
+ {
+ // InternalOXtype.g:6204:3: (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )?
+ int alt112=2;
+ int LA112_0 = input.LA(1);
+
+ if ( (LA112_0==20) ) {
+ alt112=1;
+ }
+ switch (alt112) {
+ case 1 :
+ // InternalOXtype.g:6205:4: otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')'
+ {
+ otherlv_0=(Token)match(input,20,FOLLOW_78); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_0, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0());
+
+ }
+ // InternalOXtype.g:6209:4: ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )?
+ int alt111=2;
+ int LA111_0 = input.LA(1);
+
+ if ( (LA111_0==RULE_ID||LA111_0==20||LA111_0==45) ) {
+ alt111=1;
+ }
+ switch (alt111) {
+ case 1 :
+ // InternalOXtype.g:6210:5: ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )*
+ {
+ // InternalOXtype.g:6210:5: ( (lv_paramTypes_1_0= ruleJvmTypeReference ) )
+ // InternalOXtype.g:6211:6: (lv_paramTypes_1_0= ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:6211:6: (lv_paramTypes_1_0= ruleJvmTypeReference )
+ // InternalOXtype.g:6212:7: lv_paramTypes_1_0= ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0());
+
+ }
+ pushFollow(FOLLOW_10);
+ lv_paramTypes_1_0=ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule());
+ }
+ add(
+ current,
+ "paramTypes",
+ lv_paramTypes_1_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:6229:5: (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )*
+ loop110:
+ do {
+ int alt110=2;
+ int LA110_0 = input.LA(1);
+
+ if ( (LA110_0==21) ) {
+ alt110=1;
+ }
+
+
+ switch (alt110) {
+ case 1 :
+ // InternalOXtype.g:6230:6: otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) )
+ {
+ otherlv_2=(Token)match(input,21,FOLLOW_26); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0());
+
+ }
+ // InternalOXtype.g:6234:6: ( (lv_paramTypes_3_0= ruleJvmTypeReference ) )
+ // InternalOXtype.g:6235:7: (lv_paramTypes_3_0= ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:6235:7: (lv_paramTypes_3_0= ruleJvmTypeReference )
+ // InternalOXtype.g:6236:8: lv_paramTypes_3_0= ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_10);
+ lv_paramTypes_3_0=ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule());
+ }
+ add(
+ current,
+ "paramTypes",
+ lv_paramTypes_3_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop110;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ otherlv_4=(Token)match(input,22,FOLLOW_79); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_4, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+ otherlv_5=(Token)match(input,45,FOLLOW_26); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_5, grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1());
+
+ }
+ // InternalOXtype.g:6264:3: ( (lv_returnType_6_0= ruleJvmTypeReference ) )
+ // InternalOXtype.g:6265:4: (lv_returnType_6_0= ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:6265:4: (lv_returnType_6_0= ruleJvmTypeReference )
+ // InternalOXtype.g:6266:5: lv_returnType_6_0= ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_returnType_6_0=ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule());
+ }
+ set(
+ current,
+ "returnType",
+ lv_returnType_6_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXFunctionTypeRef"
+
+
+ // $ANTLR start "entryRuleJvmParameterizedTypeReference"
+ // InternalOXtype.g:6287:1: entryRuleJvmParameterizedTypeReference returns [EObject current=null] : iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF ;
+ public final EObject entryRuleJvmParameterizedTypeReference() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleJvmParameterizedTypeReference = null;
+
+
+ try {
+ // InternalOXtype.g:6287:70: (iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF )
+ // InternalOXtype.g:6288:2: iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleJvmParameterizedTypeReference=ruleJvmParameterizedTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleJvmParameterizedTypeReference;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleJvmParameterizedTypeReference"
+
+
+ // $ANTLR start "ruleJvmParameterizedTypeReference"
+ // InternalOXtype.g:6294:1: ruleJvmParameterizedTypeReference returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) ;
+ public final EObject ruleJvmParameterizedTypeReference() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ Token otherlv_3=null;
+ Token otherlv_5=null;
+ Token otherlv_7=null;
+ Token otherlv_9=null;
+ Token otherlv_11=null;
+ Token otherlv_13=null;
+ EObject lv_arguments_2_0 = null;
+
+ EObject lv_arguments_4_0 = null;
+
+ EObject lv_arguments_10_0 = null;
+
+ EObject lv_arguments_12_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:6300:2: ( ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) )
+ // InternalOXtype.g:6301:2: ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? )
+ {
+ // InternalOXtype.g:6301:2: ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? )
+ // InternalOXtype.g:6302:3: ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )?
+ {
+ // InternalOXtype.g:6302:3: ( ( ruleQualifiedName ) )
+ // InternalOXtype.g:6303:4: ( ruleQualifiedName )
+ {
+ // InternalOXtype.g:6303:4: ( ruleQualifiedName )
+ // InternalOXtype.g:6304:5: ruleQualifiedName
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0());
+
+ }
+ pushFollow(FOLLOW_80);
+ ruleQualifiedName();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:6318:3: ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )?
+ int alt117=2;
+ alt117 = dfa117.predict(input);
+ switch (alt117) {
+ case 1 :
+ // InternalOXtype.g:6319:4: ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )*
+ {
+ // InternalOXtype.g:6319:4: ( ( '<' )=>otherlv_1= '<' )
+ // InternalOXtype.g:6320:5: ( '<' )=>otherlv_1= '<'
+ {
+ otherlv_1=(Token)match(input,32,FOLLOW_38); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0());
+
+ }
+
+ }
+
+ // InternalOXtype.g:6326:4: ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:6327:5: (lv_arguments_2_0= ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:6327:5: (lv_arguments_2_0= ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:6328:6: lv_arguments_2_0= ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_39);
+ lv_arguments_2_0=ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule());
+ }
+ add(
+ current,
+ "arguments",
+ lv_arguments_2_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:6345:4: (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )*
+ loop113:
+ do {
+ int alt113=2;
+ int LA113_0 = input.LA(1);
+
+ if ( (LA113_0==21) ) {
+ alt113=1;
+ }
+
+
+ switch (alt113) {
+ case 1 :
+ // InternalOXtype.g:6346:5: otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) )
+ {
+ otherlv_3=(Token)match(input,21,FOLLOW_38); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_3, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0());
+
+ }
+ // InternalOXtype.g:6350:5: ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:6351:6: (lv_arguments_4_0= ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:6351:6: (lv_arguments_4_0= ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:6352:7: lv_arguments_4_0= ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0());
+
+ }
+ pushFollow(FOLLOW_39);
+ lv_arguments_4_0=ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule());
+ }
+ add(
+ current,
+ "arguments",
+ lv_arguments_4_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop113;
+ }
+ } while (true);
+
+ otherlv_5=(Token)match(input,33,FOLLOW_76); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_5, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3());
+
+ }
+ // InternalOXtype.g:6374:4: ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )*
+ loop116:
+ do {
+ int alt116=2;
+ int LA116_0 = input.LA(1);
+
+ if ( (LA116_0==57) ) {
+ int LA116_2 = input.LA(2);
+
+ if ( (LA116_2==RULE_ID) ) {
+ int LA116_3 = input.LA(3);
+
+ if ( (synpred51_InternalOXtype()) ) {
+ alt116=1;
+ }
+
+
+ }
+
+
+ }
+
+
+ switch (alt116) {
+ case 1 :
+ // InternalOXtype.g:6375:5: ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )?
+ {
+ // InternalOXtype.g:6375:5: ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) )
+ // InternalOXtype.g:6376:6: ( ( () '.' ) )=> ( () otherlv_7= '.' )
+ {
+ // InternalOXtype.g:6382:6: ( () otherlv_7= '.' )
+ // InternalOXtype.g:6383:7: () otherlv_7= '.'
+ {
+ // InternalOXtype.g:6383:7: ()
+ // InternalOXtype.g:6384:8:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_7=(Token)match(input,57,FOLLOW_7); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_7, grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1());
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:6396:5: ( ( ruleValidID ) )
+ // InternalOXtype.g:6397:6: ( ruleValidID )
+ {
+ // InternalOXtype.g:6397:6: ( ruleValidID )
+ // InternalOXtype.g:6398:7: ruleValidID
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule());
+ }
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0());
+
+ }
+ pushFollow(FOLLOW_81);
+ ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:6412:5: ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )?
+ int alt115=2;
+ alt115 = dfa115.predict(input);
+ switch (alt115) {
+ case 1 :
+ // InternalOXtype.g:6413:6: ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>'
+ {
+ // InternalOXtype.g:6413:6: ( ( '<' )=>otherlv_9= '<' )
+ // InternalOXtype.g:6414:7: ( '<' )=>otherlv_9= '<'
+ {
+ otherlv_9=(Token)match(input,32,FOLLOW_38); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_9, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0());
+
+ }
+
+ }
+
+ // InternalOXtype.g:6420:6: ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:6421:7: (lv_arguments_10_0= ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:6421:7: (lv_arguments_10_0= ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:6422:8: lv_arguments_10_0= ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0());
+
+ }
+ pushFollow(FOLLOW_39);
+ lv_arguments_10_0=ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule());
+ }
+ add(
+ current,
+ "arguments",
+ lv_arguments_10_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:6439:6: (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )*
+ loop114:
+ do {
+ int alt114=2;
+ int LA114_0 = input.LA(1);
+
+ if ( (LA114_0==21) ) {
+ alt114=1;
+ }
+
+
+ switch (alt114) {
+ case 1 :
+ // InternalOXtype.g:6440:7: otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) )
+ {
+ otherlv_11=(Token)match(input,21,FOLLOW_38); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_11, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0());
+
+ }
+ // InternalOXtype.g:6444:7: ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) )
+ // InternalOXtype.g:6445:8: (lv_arguments_12_0= ruleJvmArgumentTypeReference )
+ {
+ // InternalOXtype.g:6445:8: (lv_arguments_12_0= ruleJvmArgumentTypeReference )
+ // InternalOXtype.g:6446:9: lv_arguments_12_0= ruleJvmArgumentTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0());
+
+ }
+ pushFollow(FOLLOW_39);
+ lv_arguments_12_0=ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule());
+ }
+ add(
+ current,
+ "arguments",
+ lv_arguments_12_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop114;
+ }
+ } while (true);
+
+ otherlv_13=(Token)match(input,33,FOLLOW_76); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_13, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop116;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleJvmParameterizedTypeReference"
+
+
+ // $ANTLR start "entryRuleJvmArgumentTypeReference"
+ // InternalOXtype.g:6475:1: entryRuleJvmArgumentTypeReference returns [EObject current=null] : iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF ;
+ public final EObject entryRuleJvmArgumentTypeReference() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleJvmArgumentTypeReference = null;
+
+
+ try {
+ // InternalOXtype.g:6475:65: (iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF )
+ // InternalOXtype.g:6476:2: iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleJvmArgumentTypeReference=ruleJvmArgumentTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleJvmArgumentTypeReference;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleJvmArgumentTypeReference"
+
+
+ // $ANTLR start "ruleJvmArgumentTypeReference"
+ // InternalOXtype.g:6482:1: ruleJvmArgumentTypeReference returns [EObject current=null] : (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) ;
+ public final EObject ruleJvmArgumentTypeReference() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_JvmTypeReference_0 = null;
+
+ EObject this_JvmWildcardTypeReference_1 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:6488:2: ( (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) )
+ // InternalOXtype.g:6489:2: (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference )
+ {
+ // InternalOXtype.g:6489:2: (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference )
+ int alt118=2;
+ int LA118_0 = input.LA(1);
+
+ if ( (LA118_0==RULE_ID||LA118_0==20||LA118_0==45) ) {
+ alt118=1;
+ }
+ else if ( (LA118_0==87) ) {
+ alt118=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 118, 0, input);
+
+ throw nvae;
+ }
+ switch (alt118) {
+ case 1 :
+ // InternalOXtype.g:6490:3: this_JvmTypeReference_0= ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_JvmTypeReference_0=ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_JvmTypeReference_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:6499:3: this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_2);
+ this_JvmWildcardTypeReference_1=ruleJvmWildcardTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_JvmWildcardTypeReference_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleJvmArgumentTypeReference"
+
+
+ // $ANTLR start "entryRuleJvmWildcardTypeReference"
+ // InternalOXtype.g:6511:1: entryRuleJvmWildcardTypeReference returns [EObject current=null] : iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF ;
+ public final EObject entryRuleJvmWildcardTypeReference() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleJvmWildcardTypeReference = null;
+
+
+ try {
+ // InternalOXtype.g:6511:65: (iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF )
+ // InternalOXtype.g:6512:2: iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleJvmWildcardTypeReference=ruleJvmWildcardTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleJvmWildcardTypeReference;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleJvmWildcardTypeReference"
+
+
+ // $ANTLR start "ruleJvmWildcardTypeReference"
+ // InternalOXtype.g:6518:1: ruleJvmWildcardTypeReference returns [EObject current=null] : ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) ;
+ public final EObject ruleJvmWildcardTypeReference() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ EObject lv_constraints_2_0 = null;
+
+ EObject lv_constraints_3_0 = null;
+
+ EObject lv_constraints_4_0 = null;
+
+ EObject lv_constraints_5_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:6524:2: ( ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) )
+ // InternalOXtype.g:6525:2: ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? )
+ {
+ // InternalOXtype.g:6525:2: ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? )
+ // InternalOXtype.g:6526:3: () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )?
+ {
+ // InternalOXtype.g:6526:3: ()
+ // InternalOXtype.g:6527:4:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0(),
+ current);
+
+ }
+
+ }
+
+ otherlv_1=(Token)match(input,87,FOLLOW_82); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_1, grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1());
+
+ }
+ // InternalOXtype.g:6537:3: ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )?
+ int alt121=3;
+ int LA121_0 = input.LA(1);
+
+ if ( (LA121_0==74) ) {
+ alt121=1;
+ }
+ else if ( (LA121_0==75) ) {
+ alt121=2;
+ }
+ switch (alt121) {
+ case 1 :
+ // InternalOXtype.g:6538:4: ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* )
+ {
+ // InternalOXtype.g:6538:4: ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* )
+ // InternalOXtype.g:6539:5: ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )*
+ {
+ // InternalOXtype.g:6539:5: ( (lv_constraints_2_0= ruleJvmUpperBound ) )
+ // InternalOXtype.g:6540:6: (lv_constraints_2_0= ruleJvmUpperBound )
+ {
+ // InternalOXtype.g:6540:6: (lv_constraints_2_0= ruleJvmUpperBound )
+ // InternalOXtype.g:6541:7: lv_constraints_2_0= ruleJvmUpperBound
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0());
+
+ }
+ pushFollow(FOLLOW_83);
+ lv_constraints_2_0=ruleJvmUpperBound();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule());
+ }
+ add(
+ current,
+ "constraints",
+ lv_constraints_2_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmUpperBound");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:6558:5: ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )*
+ loop119:
+ do {
+ int alt119=2;
+ int LA119_0 = input.LA(1);
+
+ if ( (LA119_0==88) ) {
+ alt119=1;
+ }
+
+
+ switch (alt119) {
+ case 1 :
+ // InternalOXtype.g:6559:6: (lv_constraints_3_0= ruleJvmUpperBoundAnded )
+ {
+ // InternalOXtype.g:6559:6: (lv_constraints_3_0= ruleJvmUpperBoundAnded )
+ // InternalOXtype.g:6560:7: lv_constraints_3_0= ruleJvmUpperBoundAnded
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0());
+
+ }
+ pushFollow(FOLLOW_83);
+ lv_constraints_3_0=ruleJvmUpperBoundAnded();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule());
+ }
+ add(
+ current,
+ "constraints",
+ lv_constraints_3_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmUpperBoundAnded");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop119;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:6579:4: ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* )
+ {
+ // InternalOXtype.g:6579:4: ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* )
+ // InternalOXtype.g:6580:5: ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )*
+ {
+ // InternalOXtype.g:6580:5: ( (lv_constraints_4_0= ruleJvmLowerBound ) )
+ // InternalOXtype.g:6581:6: (lv_constraints_4_0= ruleJvmLowerBound )
+ {
+ // InternalOXtype.g:6581:6: (lv_constraints_4_0= ruleJvmLowerBound )
+ // InternalOXtype.g:6582:7: lv_constraints_4_0= ruleJvmLowerBound
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0());
+
+ }
+ pushFollow(FOLLOW_83);
+ lv_constraints_4_0=ruleJvmLowerBound();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule());
+ }
+ add(
+ current,
+ "constraints",
+ lv_constraints_4_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmLowerBound");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:6599:5: ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )*
+ loop120:
+ do {
+ int alt120=2;
+ int LA120_0 = input.LA(1);
+
+ if ( (LA120_0==88) ) {
+ alt120=1;
+ }
+
+
+ switch (alt120) {
+ case 1 :
+ // InternalOXtype.g:6600:6: (lv_constraints_5_0= ruleJvmLowerBoundAnded )
+ {
+ // InternalOXtype.g:6600:6: (lv_constraints_5_0= ruleJvmLowerBoundAnded )
+ // InternalOXtype.g:6601:7: lv_constraints_5_0= ruleJvmLowerBoundAnded
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0());
+
+ }
+ pushFollow(FOLLOW_83);
+ lv_constraints_5_0=ruleJvmLowerBoundAnded();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule());
+ }
+ add(
+ current,
+ "constraints",
+ lv_constraints_5_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmLowerBoundAnded");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop120;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleJvmWildcardTypeReference"
+
+
+ // $ANTLR start "entryRuleJvmUpperBound"
+ // InternalOXtype.g:6624:1: entryRuleJvmUpperBound returns [EObject current=null] : iv_ruleJvmUpperBound= ruleJvmUpperBound EOF ;
+ public final EObject entryRuleJvmUpperBound() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleJvmUpperBound = null;
+
+
+ try {
+ // InternalOXtype.g:6624:54: (iv_ruleJvmUpperBound= ruleJvmUpperBound EOF )
+ // InternalOXtype.g:6625:2: iv_ruleJvmUpperBound= ruleJvmUpperBound EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getJvmUpperBoundRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleJvmUpperBound=ruleJvmUpperBound();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleJvmUpperBound;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleJvmUpperBound"
+
+
+ // $ANTLR start "ruleJvmUpperBound"
+ // InternalOXtype.g:6631:1: ruleJvmUpperBound returns [EObject current=null] : (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ;
+ public final EObject ruleJvmUpperBound() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+ EObject lv_typeReference_1_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:6637:2: ( (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) )
+ // InternalOXtype.g:6638:2: (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) )
+ {
+ // InternalOXtype.g:6638:2: (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) )
+ // InternalOXtype.g:6639:3: otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) )
+ {
+ otherlv_0=(Token)match(input,74,FOLLOW_26); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0());
+
+ }
+ // InternalOXtype.g:6643:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) )
+ // InternalOXtype.g:6644:4: (lv_typeReference_1_0= ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:6644:4: (lv_typeReference_1_0= ruleJvmTypeReference )
+ // InternalOXtype.g:6645:5: lv_typeReference_1_0= ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_typeReference_1_0=ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getJvmUpperBoundRule());
+ }
+ set(
+ current,
+ "typeReference",
+ lv_typeReference_1_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleJvmUpperBound"
+
+
+ // $ANTLR start "entryRuleJvmUpperBoundAnded"
+ // InternalOXtype.g:6666:1: entryRuleJvmUpperBoundAnded returns [EObject current=null] : iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF ;
+ public final EObject entryRuleJvmUpperBoundAnded() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleJvmUpperBoundAnded = null;
+
+
+ try {
+ // InternalOXtype.g:6666:59: (iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF )
+ // InternalOXtype.g:6667:2: iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getJvmUpperBoundAndedRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleJvmUpperBoundAnded=ruleJvmUpperBoundAnded();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleJvmUpperBoundAnded;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleJvmUpperBoundAnded"
+
+
+ // $ANTLR start "ruleJvmUpperBoundAnded"
+ // InternalOXtype.g:6673:1: ruleJvmUpperBoundAnded returns [EObject current=null] : (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ;
+ public final EObject ruleJvmUpperBoundAnded() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+ EObject lv_typeReference_1_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:6679:2: ( (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) )
+ // InternalOXtype.g:6680:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) )
+ {
+ // InternalOXtype.g:6680:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) )
+ // InternalOXtype.g:6681:3: otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) )
+ {
+ otherlv_0=(Token)match(input,88,FOLLOW_26); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0());
+
+ }
+ // InternalOXtype.g:6685:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) )
+ // InternalOXtype.g:6686:4: (lv_typeReference_1_0= ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:6686:4: (lv_typeReference_1_0= ruleJvmTypeReference )
+ // InternalOXtype.g:6687:5: lv_typeReference_1_0= ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_typeReference_1_0=ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getJvmUpperBoundAndedRule());
+ }
+ set(
+ current,
+ "typeReference",
+ lv_typeReference_1_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleJvmUpperBoundAnded"
+
+
+ // $ANTLR start "entryRuleJvmLowerBound"
+ // InternalOXtype.g:6708:1: entryRuleJvmLowerBound returns [EObject current=null] : iv_ruleJvmLowerBound= ruleJvmLowerBound EOF ;
+ public final EObject entryRuleJvmLowerBound() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleJvmLowerBound = null;
+
+
+ try {
+ // InternalOXtype.g:6708:54: (iv_ruleJvmLowerBound= ruleJvmLowerBound EOF )
+ // InternalOXtype.g:6709:2: iv_ruleJvmLowerBound= ruleJvmLowerBound EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getJvmLowerBoundRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleJvmLowerBound=ruleJvmLowerBound();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleJvmLowerBound;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleJvmLowerBound"
+
+
+ // $ANTLR start "ruleJvmLowerBound"
+ // InternalOXtype.g:6715:1: ruleJvmLowerBound returns [EObject current=null] : (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ;
+ public final EObject ruleJvmLowerBound() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+ EObject lv_typeReference_1_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:6721:2: ( (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) )
+ // InternalOXtype.g:6722:2: (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) )
+ {
+ // InternalOXtype.g:6722:2: (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) )
+ // InternalOXtype.g:6723:3: otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) )
+ {
+ otherlv_0=(Token)match(input,75,FOLLOW_26); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0());
+
+ }
+ // InternalOXtype.g:6727:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) )
+ // InternalOXtype.g:6728:4: (lv_typeReference_1_0= ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:6728:4: (lv_typeReference_1_0= ruleJvmTypeReference )
+ // InternalOXtype.g:6729:5: lv_typeReference_1_0= ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_typeReference_1_0=ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getJvmLowerBoundRule());
+ }
+ set(
+ current,
+ "typeReference",
+ lv_typeReference_1_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleJvmLowerBound"
+
+
+ // $ANTLR start "entryRuleJvmLowerBoundAnded"
+ // InternalOXtype.g:6750:1: entryRuleJvmLowerBoundAnded returns [EObject current=null] : iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF ;
+ public final EObject entryRuleJvmLowerBoundAnded() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleJvmLowerBoundAnded = null;
+
+
+ try {
+ // InternalOXtype.g:6750:59: (iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF )
+ // InternalOXtype.g:6751:2: iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getJvmLowerBoundAndedRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleJvmLowerBoundAnded=ruleJvmLowerBoundAnded();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleJvmLowerBoundAnded;
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleJvmLowerBoundAnded"
+
+
+ // $ANTLR start "ruleJvmLowerBoundAnded"
+ // InternalOXtype.g:6757:1: ruleJvmLowerBoundAnded returns [EObject current=null] : (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ;
+ public final EObject ruleJvmLowerBoundAnded() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+ EObject lv_typeReference_1_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:6763:2: ( (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) )
+ // InternalOXtype.g:6764:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) )
+ {
+ // InternalOXtype.g:6764:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) )
+ // InternalOXtype.g:6765:3: otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) )
+ {
+ otherlv_0=(Token)match(input,88,FOLLOW_26); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0());
+
+ }
+ // InternalOXtype.g:6769:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) )
+ // InternalOXtype.g:6770:4: (lv_typeReference_1_0= ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:6770:4: (lv_typeReference_1_0= ruleJvmTypeReference )
+ // InternalOXtype.g:6771:5: lv_typeReference_1_0= ruleJvmTypeReference
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_2);
+ lv_typeReference_1_0=ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getJvmLowerBoundAndedRule());
+ }
+ set(
+ current,
+ "typeReference",
+ lv_typeReference_1_0,
+ "org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleJvmLowerBoundAnded"
+
+
+ // $ANTLR start "entryRuleQualifiedNameWithWildcard"
+ // InternalOXtype.g:6792:1: entryRuleQualifiedNameWithWildcard returns [String current=null] : iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF ;
+ public final String entryRuleQualifiedNameWithWildcard() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleQualifiedNameWithWildcard = null;
+
+
+ try {
+ // InternalOXtype.g:6792:65: (iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF )
+ // InternalOXtype.g:6793:2: iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getQualifiedNameWithWildcardRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleQualifiedNameWithWildcard=ruleQualifiedNameWithWildcard();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleQualifiedNameWithWildcard.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleQualifiedNameWithWildcard"
+
+
+ // $ANTLR start "ruleQualifiedNameWithWildcard"
+ // InternalOXtype.g:6799:1: ruleQualifiedNameWithWildcard returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) ;
+ public final AntlrDatatypeRuleToken ruleQualifiedNameWithWildcard() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token kw=null;
+ AntlrDatatypeRuleToken this_QualifiedName_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:6805:2: ( (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) )
+ // InternalOXtype.g:6806:2: (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' )
+ {
+ // InternalOXtype.g:6806:2: (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' )
+ // InternalOXtype.g:6807:3: this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*'
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_84);
+ this_QualifiedName_0=ruleQualifiedName();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(this_QualifiedName_0);
+
+ }
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+ kw=(Token)match(input,57,FOLLOW_85); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1());
+
+ }
+ kw=(Token)match(input,16,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleQualifiedNameWithWildcard"
+
+
+ // $ANTLR start "entryRuleValidID"
+ // InternalOXtype.g:6831:1: entryRuleValidID returns [String current=null] : iv_ruleValidID= ruleValidID EOF ;
+ public final String entryRuleValidID() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleValidID = null;
+
+
+ try {
+ // InternalOXtype.g:6831:47: (iv_ruleValidID= ruleValidID EOF )
+ // InternalOXtype.g:6832:2: iv_ruleValidID= ruleValidID EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getValidIDRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleValidID=ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleValidID.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleValidID"
+
+
+ // $ANTLR start "ruleValidID"
+ // InternalOXtype.g:6838:1: ruleValidID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_ID_0= RULE_ID ;
+ public final AntlrDatatypeRuleToken ruleValidID() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token this_ID_0=null;
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:6844:2: (this_ID_0= RULE_ID )
+ // InternalOXtype.g:6845:2: this_ID_0= RULE_ID
+ {
+ this_ID_0=(Token)match(input,RULE_ID,FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(this_ID_0);
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_ID_0, grammarAccess.getValidIDAccess().getIDTerminalRuleCall());
+
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleValidID"
+
+
+ // $ANTLR start "entryRuleQualifiedNameInStaticImport"
+ // InternalOXtype.g:6855:1: entryRuleQualifiedNameInStaticImport returns [String current=null] : iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF ;
+ public final String entryRuleQualifiedNameInStaticImport() throws RecognitionException {
+ String current = null;
+
+ AntlrDatatypeRuleToken iv_ruleQualifiedNameInStaticImport = null;
+
+
+ try {
+ // InternalOXtype.g:6855:67: (iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF )
+ // InternalOXtype.g:6856:2: iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getQualifiedNameInStaticImportRule());
+ }
+ pushFollow(FOLLOW_1);
+ iv_ruleQualifiedNameInStaticImport=ruleQualifiedNameInStaticImport();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleQualifiedNameInStaticImport.getText();
+ }
+ match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleQualifiedNameInStaticImport"
+
+
+ // $ANTLR start "ruleQualifiedNameInStaticImport"
+ // InternalOXtype.g:6862:1: ruleQualifiedNameInStaticImport returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ValidID_0= ruleValidID kw= '.' )+ ;
+ public final AntlrDatatypeRuleToken ruleQualifiedNameInStaticImport() throws RecognitionException {
+ AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+ Token kw=null;
+ AntlrDatatypeRuleToken this_ValidID_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalOXtype.g:6868:2: ( (this_ValidID_0= ruleValidID kw= '.' )+ )
+ // InternalOXtype.g:6869:2: (this_ValidID_0= ruleValidID kw= '.' )+
+ {
+ // InternalOXtype.g:6869:2: (this_ValidID_0= ruleValidID kw= '.' )+
+ int cnt122=0;
+ loop122:
+ do {
+ int alt122=2;
+ int LA122_0 = input.LA(1);
+
+ if ( (LA122_0==RULE_ID) ) {
+ int LA122_2 = input.LA(2);
+
+ if ( (LA122_2==57) ) {
+ alt122=1;
+ }
+
+
+ }
+
+
+ switch (alt122) {
+ case 1 :
+ // InternalOXtype.g:6870:3: this_ValidID_0= ruleValidID kw= '.'
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_84);
+ this_ValidID_0=ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(this_ValidID_0);
+
+ }
+ if ( state.backtracking==0 ) {
+
+ afterParserOrEnumRuleCall();
+
+ }
+ kw=(Token)match(input,57,FOLLOW_86); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current.merge(kw);
+ newLeafNode(kw, grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1());
+
+ }
+
+ }
+ break;
+
+ default :
+ if ( cnt122 >= 1 ) break loop122;
+ if (state.backtracking>0) {state.failed=true; return current;}
+ EarlyExitException eee =
+ new EarlyExitException(122, input);
+ throw eee;
+ }
+ cnt122++;
+ } while (true);
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleQualifiedNameInStaticImport"
+
+ // $ANTLR start synpred1_InternalOXtype
+ public final void synpred1_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:301:5: ( '(' )
+ // InternalOXtype.g:301:6: '('
+ {
+ match(input,20,FOLLOW_2); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred1_InternalOXtype
+
+ // $ANTLR start synpred2_InternalOXtype
+ public final void synpred2_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:310:7: ( ( ( ( ruleValidID ) ) '=' ) )
+ // InternalOXtype.g:310:8: ( ( ( ruleValidID ) ) '=' )
+ {
+ // InternalOXtype.g:310:8: ( ( ( ruleValidID ) ) '=' )
+ // InternalOXtype.g:311:8: ( ( ruleValidID ) ) '='
+ {
+ // InternalOXtype.g:311:8: ( ( ruleValidID ) )
+ // InternalOXtype.g:312:9: ( ruleValidID )
+ {
+ // InternalOXtype.g:312:9: ( ruleValidID )
+ // InternalOXtype.g:313:10: ruleValidID
+ {
+ pushFollow(FOLLOW_12);
+ ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ match(input,23,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred2_InternalOXtype
+
+ // $ANTLR start synpred5_InternalOXtype
+ public final void synpred5_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:490:5: ( ( () '#' '[' ) )
+ // InternalOXtype.g:490:6: ( () '#' '[' )
+ {
+ // InternalOXtype.g:490:6: ( () '#' '[' )
+ // InternalOXtype.g:491:6: () '#' '['
+ {
+ // InternalOXtype.g:491:6: ()
+ // InternalOXtype.g:492:6:
+ {
+ }
+
+ match(input,24,FOLLOW_14); if (state.failed) return ;
+ match(input,25,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred5_InternalOXtype
+
+ // $ANTLR start synpred6_InternalOXtype
+ public final void synpred6_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:632:5: ( ( () '#' '[' ) )
+ // InternalOXtype.g:632:6: ( () '#' '[' )
+ {
+ // InternalOXtype.g:632:6: ( () '#' '[' )
+ // InternalOXtype.g:633:6: () '#' '['
+ {
+ // InternalOXtype.g:633:6: ()
+ // InternalOXtype.g:634:6:
+ {
+ }
+
+ match(input,24,FOLLOW_14); if (state.failed) return ;
+ match(input,25,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred6_InternalOXtype
+
+ // $ANTLR start synpred7_InternalOXtype
+ public final void synpred7_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:860:6: ( ( () ( ( ruleOpMultiAssign ) ) ) )
+ // InternalOXtype.g:860:7: ( () ( ( ruleOpMultiAssign ) ) )
+ {
+ // InternalOXtype.g:860:7: ( () ( ( ruleOpMultiAssign ) ) )
+ // InternalOXtype.g:861:7: () ( ( ruleOpMultiAssign ) )
+ {
+ // InternalOXtype.g:861:7: ()
+ // InternalOXtype.g:862:7:
+ {
+ }
+
+ // InternalOXtype.g:863:7: ( ( ruleOpMultiAssign ) )
+ // InternalOXtype.g:864:8: ( ruleOpMultiAssign )
+ {
+ // InternalOXtype.g:864:8: ( ruleOpMultiAssign )
+ // InternalOXtype.g:865:9: ruleOpMultiAssign
+ {
+ pushFollow(FOLLOW_2);
+ ruleOpMultiAssign();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred7_InternalOXtype
+
+ // $ANTLR start synpred8_InternalOXtype
+ public final void synpred8_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:1054:5: ( ( () ( ( ruleOpOr ) ) ) )
+ // InternalOXtype.g:1054:6: ( () ( ( ruleOpOr ) ) )
+ {
+ // InternalOXtype.g:1054:6: ( () ( ( ruleOpOr ) ) )
+ // InternalOXtype.g:1055:6: () ( ( ruleOpOr ) )
+ {
+ // InternalOXtype.g:1055:6: ()
+ // InternalOXtype.g:1056:6:
+ {
+ }
+
+ // InternalOXtype.g:1057:6: ( ( ruleOpOr ) )
+ // InternalOXtype.g:1058:7: ( ruleOpOr )
+ {
+ // InternalOXtype.g:1058:7: ( ruleOpOr )
+ // InternalOXtype.g:1059:8: ruleOpOr
+ {
+ pushFollow(FOLLOW_2);
+ ruleOpOr();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred8_InternalOXtype
+
+ // $ANTLR start synpred9_InternalOXtype
+ public final void synpred9_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:1161:5: ( ( () ( ( ruleOpAnd ) ) ) )
+ // InternalOXtype.g:1161:6: ( () ( ( ruleOpAnd ) ) )
+ {
+ // InternalOXtype.g:1161:6: ( () ( ( ruleOpAnd ) ) )
+ // InternalOXtype.g:1162:6: () ( ( ruleOpAnd ) )
+ {
+ // InternalOXtype.g:1162:6: ()
+ // InternalOXtype.g:1163:6:
+ {
+ }
+
+ // InternalOXtype.g:1164:6: ( ( ruleOpAnd ) )
+ // InternalOXtype.g:1165:7: ( ruleOpAnd )
+ {
+ // InternalOXtype.g:1165:7: ( ruleOpAnd )
+ // InternalOXtype.g:1166:8: ruleOpAnd
+ {
+ pushFollow(FOLLOW_2);
+ ruleOpAnd();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred9_InternalOXtype
+
+ // $ANTLR start synpred10_InternalOXtype
+ public final void synpred10_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:1268:5: ( ( () ( ( ruleOpEquality ) ) ) )
+ // InternalOXtype.g:1268:6: ( () ( ( ruleOpEquality ) ) )
+ {
+ // InternalOXtype.g:1268:6: ( () ( ( ruleOpEquality ) ) )
+ // InternalOXtype.g:1269:6: () ( ( ruleOpEquality ) )
+ {
+ // InternalOXtype.g:1269:6: ()
+ // InternalOXtype.g:1270:6:
+ {
+ }
+
+ // InternalOXtype.g:1271:6: ( ( ruleOpEquality ) )
+ // InternalOXtype.g:1272:7: ( ruleOpEquality )
+ {
+ // InternalOXtype.g:1272:7: ( ruleOpEquality )
+ // InternalOXtype.g:1273:8: ruleOpEquality
+ {
+ pushFollow(FOLLOW_2);
+ ruleOpEquality();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred10_InternalOXtype
+
+ // $ANTLR start synpred11_InternalOXtype
+ public final void synpred11_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:1396:6: ( ( () 'instanceof' ) )
+ // InternalOXtype.g:1396:7: ( () 'instanceof' )
+ {
+ // InternalOXtype.g:1396:7: ( () 'instanceof' )
+ // InternalOXtype.g:1397:7: () 'instanceof'
+ {
+ // InternalOXtype.g:1397:7: ()
+ // InternalOXtype.g:1398:7:
+ {
+ }
+
+ match(input,41,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred11_InternalOXtype
+
+ // $ANTLR start synpred12_InternalOXtype
+ public final void synpred12_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:1439:6: ( ( () ( ( ruleOpCompare ) ) ) )
+ // InternalOXtype.g:1439:7: ( () ( ( ruleOpCompare ) ) )
+ {
+ // InternalOXtype.g:1439:7: ( () ( ( ruleOpCompare ) ) )
+ // InternalOXtype.g:1440:7: () ( ( ruleOpCompare ) )
+ {
+ // InternalOXtype.g:1440:7: ()
+ // InternalOXtype.g:1441:7:
+ {
+ }
+
+ // InternalOXtype.g:1442:7: ( ( ruleOpCompare ) )
+ // InternalOXtype.g:1443:8: ( ruleOpCompare )
+ {
+ // InternalOXtype.g:1443:8: ( ruleOpCompare )
+ // InternalOXtype.g:1444:9: ruleOpCompare
+ {
+ pushFollow(FOLLOW_2);
+ ruleOpCompare();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred12_InternalOXtype
+
+ // $ANTLR start synpred13_InternalOXtype
+ public final void synpred13_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:1574:5: ( ( () ( ( ruleOpOther ) ) ) )
+ // InternalOXtype.g:1574:6: ( () ( ( ruleOpOther ) ) )
+ {
+ // InternalOXtype.g:1574:6: ( () ( ( ruleOpOther ) ) )
+ // InternalOXtype.g:1575:6: () ( ( ruleOpOther ) )
+ {
+ // InternalOXtype.g:1575:6: ()
+ // InternalOXtype.g:1576:6:
+ {
+ }
+
+ // InternalOXtype.g:1577:6: ( ( ruleOpOther ) )
+ // InternalOXtype.g:1578:7: ( ruleOpOther )
+ {
+ // InternalOXtype.g:1578:7: ( ruleOpOther )
+ // InternalOXtype.g:1579:8: ruleOpOther
+ {
+ pushFollow(FOLLOW_2);
+ ruleOpOther();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred13_InternalOXtype
+
+ // $ANTLR start synpred14_InternalOXtype
+ public final void synpred14_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:1694:6: ( ( '>' '>' ) )
+ // InternalOXtype.g:1694:7: ( '>' '>' )
+ {
+ // InternalOXtype.g:1694:7: ( '>' '>' )
+ // InternalOXtype.g:1695:7: '>' '>'
+ {
+ match(input,33,FOLLOW_29); if (state.failed) return ;
+ match(input,33,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred14_InternalOXtype
+
+ // $ANTLR start synpred15_InternalOXtype
+ public final void synpred15_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:1729:6: ( ( '<' '<' ) )
+ // InternalOXtype.g:1729:7: ( '<' '<' )
+ {
+ // InternalOXtype.g:1729:7: ( '<' '<' )
+ // InternalOXtype.g:1730:7: '<' '<'
+ {
+ match(input,32,FOLLOW_19); if (state.failed) return ;
+ match(input,32,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred15_InternalOXtype
+
+ // $ANTLR start synpred16_InternalOXtype
+ public final void synpred16_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:1802:5: ( ( () ( ( ruleOpAdd ) ) ) )
+ // InternalOXtype.g:1802:6: ( () ( ( ruleOpAdd ) ) )
+ {
+ // InternalOXtype.g:1802:6: ( () ( ( ruleOpAdd ) ) )
+ // InternalOXtype.g:1803:6: () ( ( ruleOpAdd ) )
+ {
+ // InternalOXtype.g:1803:6: ()
+ // InternalOXtype.g:1804:6:
+ {
+ }
+
+ // InternalOXtype.g:1805:6: ( ( ruleOpAdd ) )
+ // InternalOXtype.g:1806:7: ( ruleOpAdd )
+ {
+ // InternalOXtype.g:1806:7: ( ruleOpAdd )
+ // InternalOXtype.g:1807:8: ruleOpAdd
+ {
+ pushFollow(FOLLOW_2);
+ ruleOpAdd();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred16_InternalOXtype
+
+ // $ANTLR start synpred17_InternalOXtype
+ public final void synpred17_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:1917:5: ( ( () ( ( ruleOpMulti ) ) ) )
+ // InternalOXtype.g:1917:6: ( () ( ( ruleOpMulti ) ) )
+ {
+ // InternalOXtype.g:1917:6: ( () ( ( ruleOpMulti ) ) )
+ // InternalOXtype.g:1918:6: () ( ( ruleOpMulti ) )
+ {
+ // InternalOXtype.g:1918:6: ()
+ // InternalOXtype.g:1919:6:
+ {
+ }
+
+ // InternalOXtype.g:1920:6: ( ( ruleOpMulti ) )
+ // InternalOXtype.g:1921:7: ( ruleOpMulti )
+ {
+ // InternalOXtype.g:1921:7: ( ruleOpMulti )
+ // InternalOXtype.g:1922:8: ruleOpMulti
+ {
+ pushFollow(FOLLOW_2);
+ ruleOpMulti();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred17_InternalOXtype
+
+ // $ANTLR start synpred18_InternalOXtype
+ public final void synpred18_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2152:5: ( ( () 'as' ) )
+ // InternalOXtype.g:2152:6: ( () 'as' )
+ {
+ // InternalOXtype.g:2152:6: ( () 'as' )
+ // InternalOXtype.g:2153:6: () 'as'
+ {
+ // InternalOXtype.g:2153:6: ()
+ // InternalOXtype.g:2154:6:
+ {
+ }
+
+ match(input,54,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred18_InternalOXtype
+
+ // $ANTLR start synpred19_InternalOXtype
+ public final void synpred19_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2220:4: ( ( () ( ( ruleOpPostfix ) ) ) )
+ // InternalOXtype.g:2220:5: ( () ( ( ruleOpPostfix ) ) )
+ {
+ // InternalOXtype.g:2220:5: ( () ( ( ruleOpPostfix ) ) )
+ // InternalOXtype.g:2221:5: () ( ( ruleOpPostfix ) )
+ {
+ // InternalOXtype.g:2221:5: ()
+ // InternalOXtype.g:2222:5:
+ {
+ }
+
+ // InternalOXtype.g:2223:5: ( ( ruleOpPostfix ) )
+ // InternalOXtype.g:2224:6: ( ruleOpPostfix )
+ {
+ // InternalOXtype.g:2224:6: ( ruleOpPostfix )
+ // InternalOXtype.g:2225:7: ruleOpPostfix
+ {
+ pushFollow(FOLLOW_2);
+ ruleOpPostfix();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred19_InternalOXtype
+
+ // $ANTLR start synpred20_InternalOXtype
+ public final void synpred20_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2316:6: ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )
+ // InternalOXtype.g:2316:7: ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign )
+ {
+ // InternalOXtype.g:2316:7: ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign )
+ // InternalOXtype.g:2317:7: () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign
+ {
+ // InternalOXtype.g:2317:7: ()
+ // InternalOXtype.g:2318:7:
+ {
+ }
+
+ // InternalOXtype.g:2319:7: ( '.' | ( ( '::' ) ) )
+ int alt123=2;
+ int LA123_0 = input.LA(1);
+
+ if ( (LA123_0==57) ) {
+ alt123=1;
+ }
+ else if ( (LA123_0==58) ) {
+ alt123=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 123, 0, input);
+
+ throw nvae;
+ }
+ switch (alt123) {
+ case 1 :
+ // InternalOXtype.g:2320:8: '.'
+ {
+ match(input,57,FOLLOW_36); if (state.failed) return ;
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2322:8: ( ( '::' ) )
+ {
+ // InternalOXtype.g:2322:8: ( ( '::' ) )
+ // InternalOXtype.g:2323:9: ( '::' )
+ {
+ // InternalOXtype.g:2323:9: ( '::' )
+ // InternalOXtype.g:2324:10: '::'
+ {
+ match(input,58,FOLLOW_36); if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:2328:7: ( ( ruleFeatureCallID ) )
+ // InternalOXtype.g:2329:8: ( ruleFeatureCallID )
+ {
+ // InternalOXtype.g:2329:8: ( ruleFeatureCallID )
+ // InternalOXtype.g:2330:9: ruleFeatureCallID
+ {
+ pushFollow(FOLLOW_12);
+ ruleFeatureCallID();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ pushFollow(FOLLOW_2);
+ ruleOpSingleAssign();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred20_InternalOXtype
+
+ // $ANTLR start synpred21_InternalOXtype
+ public final void synpred21_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2413:6: ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )
+ // InternalOXtype.g:2413:7: ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) )
+ {
+ // InternalOXtype.g:2413:7: ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) )
+ // InternalOXtype.g:2414:7: () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) )
+ {
+ // InternalOXtype.g:2414:7: ()
+ // InternalOXtype.g:2415:7:
+ {
+ }
+
+ // InternalOXtype.g:2416:7: ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) )
+ int alt124=3;
+ switch ( input.LA(1) ) {
+ case 57:
+ {
+ alt124=1;
+ }
+ break;
+ case 59:
+ {
+ alt124=2;
+ }
+ break;
+ case 58:
+ {
+ alt124=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 124, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt124) {
+ case 1 :
+ // InternalOXtype.g:2417:8: '.'
+ {
+ match(input,57,FOLLOW_2); if (state.failed) return ;
+
+ }
+ break;
+ case 2 :
+ // InternalOXtype.g:2419:8: ( ( '?.' ) )
+ {
+ // InternalOXtype.g:2419:8: ( ( '?.' ) )
+ // InternalOXtype.g:2420:9: ( '?.' )
+ {
+ // InternalOXtype.g:2420:9: ( '?.' )
+ // InternalOXtype.g:2421:10: '?.'
+ {
+ match(input,59,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // InternalOXtype.g:2425:8: ( ( '::' ) )
+ {
+ // InternalOXtype.g:2425:8: ( ( '::' ) )
+ // InternalOXtype.g:2426:9: ( '::' )
+ {
+ // InternalOXtype.g:2426:9: ( '::' )
+ // InternalOXtype.g:2427:10: '::'
+ {
+ match(input,58,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred21_InternalOXtype
+
+ // $ANTLR start synpred22_InternalOXtype
+ public final void synpred22_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2551:7: ( ( '(' ) )
+ // InternalOXtype.g:2551:8: ( '(' )
+ {
+ // InternalOXtype.g:2551:8: ( '(' )
+ // InternalOXtype.g:2552:8: '('
+ {
+ match(input,20,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred22_InternalOXtype
+
+ // $ANTLR start synpred23_InternalOXtype
+ public final void synpred23_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2570:8: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )
+ // InternalOXtype.g:2570:9: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) )
+ {
+ // InternalOXtype.g:2570:9: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) )
+ // InternalOXtype.g:2571:9: () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) )
+ {
+ // InternalOXtype.g:2571:9: ()
+ // InternalOXtype.g:2572:9:
+ {
+ }
+
+ // InternalOXtype.g:2573:9: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )?
+ int alt126=2;
+ int LA126_0 = input.LA(1);
+
+ if ( (LA126_0==RULE_ID||LA126_0==20||LA126_0==45) ) {
+ alt126=1;
+ }
+ switch (alt126) {
+ case 1 :
+ // InternalOXtype.g:2574:10: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )*
+ {
+ // InternalOXtype.g:2574:10: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:2575:11: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:2575:11: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:2576:12: ruleJvmFormalParameter
+ {
+ pushFollow(FOLLOW_47);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:2579:10: ( ',' ( ( ruleJvmFormalParameter ) ) )*
+ loop125:
+ do {
+ int alt125=2;
+ int LA125_0 = input.LA(1);
+
+ if ( (LA125_0==21) ) {
+ alt125=1;
+ }
+
+
+ switch (alt125) {
+ case 1 :
+ // InternalOXtype.g:2580:11: ',' ( ( ruleJvmFormalParameter ) )
+ {
+ match(input,21,FOLLOW_26); if (state.failed) return ;
+ // InternalOXtype.g:2581:11: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:2582:12: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:2582:12: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:2583:13: ruleJvmFormalParameter
+ {
+ pushFollow(FOLLOW_47);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop125;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:2588:9: ( ( '|' ) )
+ // InternalOXtype.g:2589:10: ( '|' )
+ {
+ // InternalOXtype.g:2589:10: ( '|' )
+ // InternalOXtype.g:2590:11: '|'
+ {
+ match(input,62,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred23_InternalOXtype
+
+ // $ANTLR start synpred24_InternalOXtype
+ public final void synpred24_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2667:6: ( ( () '[' ) )
+ // InternalOXtype.g:2667:7: ( () '[' )
+ {
+ // InternalOXtype.g:2667:7: ( () '[' )
+ // InternalOXtype.g:2668:7: () '['
+ {
+ // InternalOXtype.g:2668:7: ()
+ // InternalOXtype.g:2669:7:
+ {
+ }
+
+ match(input,25,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred24_InternalOXtype
+
+ // $ANTLR start synpred25_InternalOXtype
+ public final void synpred25_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2740:4: ( ( () 'synchronized' '(' ) )
+ // InternalOXtype.g:2740:5: ( () 'synchronized' '(' )
+ {
+ // InternalOXtype.g:2740:5: ( () 'synchronized' '(' )
+ // InternalOXtype.g:2741:5: () 'synchronized' '('
+ {
+ // InternalOXtype.g:2741:5: ()
+ // InternalOXtype.g:2742:5:
+ {
+ }
+
+ match(input,85,FOLLOW_52); if (state.failed) return ;
+ match(input,20,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred25_InternalOXtype
+
+ // $ANTLR start synpred26_InternalOXtype
+ public final void synpred26_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2785:4: ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )
+ // InternalOXtype.g:2785:5: ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' )
+ {
+ // InternalOXtype.g:2785:5: ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' )
+ // InternalOXtype.g:2786:5: () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':'
+ {
+ // InternalOXtype.g:2786:5: ()
+ // InternalOXtype.g:2787:5:
+ {
+ }
+
+ match(input,69,FOLLOW_52); if (state.failed) return ;
+ match(input,20,FOLLOW_26); if (state.failed) return ;
+ // InternalOXtype.g:2790:5: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:2791:6: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:2791:6: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:2792:7: ruleJvmFormalParameter
+ {
+ pushFollow(FOLLOW_55);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ match(input,66,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred26_InternalOXtype
+
+ // $ANTLR start synpred27_InternalOXtype
+ public final void synpred27_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:2899:4: ( ( () '[' ) )
+ // InternalOXtype.g:2899:5: ( () '[' )
+ {
+ // InternalOXtype.g:2899:5: ( () '[' )
+ // InternalOXtype.g:2900:5: () '['
+ {
+ // InternalOXtype.g:2900:5: ()
+ // InternalOXtype.g:2901:5:
+ {
+ }
+
+ match(input,25,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred27_InternalOXtype
+
+ // $ANTLR start synpred29_InternalOXtype
+ public final void synpred29_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:3204:4: ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )
+ // InternalOXtype.g:3204:5: ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) )
+ {
+ // InternalOXtype.g:3204:5: ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) )
+ // InternalOXtype.g:3205:5: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) )
+ {
+ // InternalOXtype.g:3205:5: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )?
+ int alt128=2;
+ int LA128_0 = input.LA(1);
+
+ if ( (LA128_0==RULE_ID||LA128_0==20||LA128_0==45) ) {
+ alt128=1;
+ }
+ switch (alt128) {
+ case 1 :
+ // InternalOXtype.g:3206:6: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )*
+ {
+ // InternalOXtype.g:3206:6: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:3207:7: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:3207:7: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:3208:8: ruleJvmFormalParameter
+ {
+ pushFollow(FOLLOW_47);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:3211:6: ( ',' ( ( ruleJvmFormalParameter ) ) )*
+ loop127:
+ do {
+ int alt127=2;
+ int LA127_0 = input.LA(1);
+
+ if ( (LA127_0==21) ) {
+ alt127=1;
+ }
+
+
+ switch (alt127) {
+ case 1 :
+ // InternalOXtype.g:3212:7: ',' ( ( ruleJvmFormalParameter ) )
+ {
+ match(input,21,FOLLOW_26); if (state.failed) return ;
+ // InternalOXtype.g:3213:7: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:3214:8: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:3214:8: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:3215:9: ruleJvmFormalParameter
+ {
+ pushFollow(FOLLOW_47);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop127;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:3220:5: ( ( '|' ) )
+ // InternalOXtype.g:3221:6: ( '|' )
+ {
+ // InternalOXtype.g:3221:6: ( '|' )
+ // InternalOXtype.g:3222:7: '|'
+ {
+ match(input,62,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred29_InternalOXtype
+
+ // $ANTLR start synpred31_InternalOXtype
+ public final void synpred31_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:3613:5: ( 'else' )
+ // InternalOXtype.g:3613:6: 'else'
+ {
+ match(input,64,FOLLOW_2); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred31_InternalOXtype
+
+ // $ANTLR start synpred32_InternalOXtype
+ public final void synpred32_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:3672:6: ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )
+ // InternalOXtype.g:3672:7: ( '(' ( ( ruleJvmFormalParameter ) ) ':' )
+ {
+ // InternalOXtype.g:3672:7: ( '(' ( ( ruleJvmFormalParameter ) ) ':' )
+ // InternalOXtype.g:3673:7: '(' ( ( ruleJvmFormalParameter ) ) ':'
+ {
+ match(input,20,FOLLOW_26); if (state.failed) return ;
+ // InternalOXtype.g:3674:7: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:3675:8: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:3675:8: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:3676:9: ruleJvmFormalParameter
+ {
+ pushFollow(FOLLOW_55);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ match(input,66,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred32_InternalOXtype
+
+ // $ANTLR start synpred33_InternalOXtype
+ public final void synpred33_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:3739:6: ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )
+ // InternalOXtype.g:3739:7: ( ( ( ruleJvmFormalParameter ) ) ':' )
+ {
+ // InternalOXtype.g:3739:7: ( ( ( ruleJvmFormalParameter ) ) ':' )
+ // InternalOXtype.g:3740:7: ( ( ruleJvmFormalParameter ) ) ':'
+ {
+ // InternalOXtype.g:3740:7: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:3741:8: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:3741:8: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:3742:9: ruleJvmFormalParameter
+ {
+ pushFollow(FOLLOW_55);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ match(input,66,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred33_InternalOXtype
+
+ // $ANTLR start synpred35_InternalOXtype
+ public final void synpred35_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:4557:5: ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )
+ // InternalOXtype.g:4557:6: ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) )
+ {
+ // InternalOXtype.g:4557:6: ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) )
+ // InternalOXtype.g:4558:6: ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) )
+ {
+ // InternalOXtype.g:4558:6: ( ( ruleJvmTypeReference ) )
+ // InternalOXtype.g:4559:7: ( ruleJvmTypeReference )
+ {
+ // InternalOXtype.g:4559:7: ( ruleJvmTypeReference )
+ // InternalOXtype.g:4560:8: ruleJvmTypeReference
+ {
+ pushFollow(FOLLOW_7);
+ ruleJvmTypeReference();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:4563:6: ( ( ruleValidID ) )
+ // InternalOXtype.g:4564:7: ( ruleValidID )
+ {
+ // InternalOXtype.g:4564:7: ( ruleValidID )
+ // InternalOXtype.g:4565:8: ruleValidID
+ {
+ pushFollow(FOLLOW_2);
+ ruleValidID();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred35_InternalOXtype
+
+ // $ANTLR start synpred36_InternalOXtype
+ public final void synpred36_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:4869:5: ( ( '(' ) )
+ // InternalOXtype.g:4869:6: ( '(' )
+ {
+ // InternalOXtype.g:4869:6: ( '(' )
+ // InternalOXtype.g:4870:6: '('
+ {
+ match(input,20,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred36_InternalOXtype
+
+ // $ANTLR start synpred37_InternalOXtype
+ public final void synpred37_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:4888:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )
+ // InternalOXtype.g:4888:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) )
+ {
+ // InternalOXtype.g:4888:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) )
+ // InternalOXtype.g:4889:7: () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) )
+ {
+ // InternalOXtype.g:4889:7: ()
+ // InternalOXtype.g:4890:7:
+ {
+ }
+
+ // InternalOXtype.g:4891:7: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )?
+ int alt132=2;
+ int LA132_0 = input.LA(1);
+
+ if ( (LA132_0==RULE_ID||LA132_0==20||LA132_0==45) ) {
+ alt132=1;
+ }
+ switch (alt132) {
+ case 1 :
+ // InternalOXtype.g:4892:8: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )*
+ {
+ // InternalOXtype.g:4892:8: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:4893:9: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:4893:9: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:4894:10: ruleJvmFormalParameter
+ {
+ pushFollow(FOLLOW_47);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:4897:8: ( ',' ( ( ruleJvmFormalParameter ) ) )*
+ loop131:
+ do {
+ int alt131=2;
+ int LA131_0 = input.LA(1);
+
+ if ( (LA131_0==21) ) {
+ alt131=1;
+ }
+
+
+ switch (alt131) {
+ case 1 :
+ // InternalOXtype.g:4898:9: ',' ( ( ruleJvmFormalParameter ) )
+ {
+ match(input,21,FOLLOW_26); if (state.failed) return ;
+ // InternalOXtype.g:4899:9: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:4900:10: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:4900:10: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:4901:11: ruleJvmFormalParameter
+ {
+ pushFollow(FOLLOW_47);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop131;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:4906:7: ( ( '|' ) )
+ // InternalOXtype.g:4907:8: ( '|' )
+ {
+ // InternalOXtype.g:4907:8: ( '|' )
+ // InternalOXtype.g:4908:9: '|'
+ {
+ match(input,62,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred37_InternalOXtype
+
+ // $ANTLR start synpred38_InternalOXtype
+ public final void synpred38_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:4985:4: ( ( () '[' ) )
+ // InternalOXtype.g:4985:5: ( () '[' )
+ {
+ // InternalOXtype.g:4985:5: ( () '[' )
+ // InternalOXtype.g:4986:5: () '['
+ {
+ // InternalOXtype.g:4986:5: ()
+ // InternalOXtype.g:4987:5:
+ {
+ }
+
+ match(input,25,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred38_InternalOXtype
+
+ // $ANTLR start synpred39_InternalOXtype
+ public final void synpred39_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:5145:5: ( '<' )
+ // InternalOXtype.g:5145:6: '<'
+ {
+ match(input,32,FOLLOW_2); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred39_InternalOXtype
+
+ // $ANTLR start synpred40_InternalOXtype
+ public final void synpred40_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:5202:5: ( ( '(' ) )
+ // InternalOXtype.g:5202:6: ( '(' )
+ {
+ // InternalOXtype.g:5202:6: ( '(' )
+ // InternalOXtype.g:5203:6: '('
+ {
+ match(input,20,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred40_InternalOXtype
+
+ // $ANTLR start synpred41_InternalOXtype
+ public final void synpred41_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:5221:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )
+ // InternalOXtype.g:5221:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) )
+ {
+ // InternalOXtype.g:5221:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) )
+ // InternalOXtype.g:5222:7: () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) )
+ {
+ // InternalOXtype.g:5222:7: ()
+ // InternalOXtype.g:5223:7:
+ {
+ }
+
+ // InternalOXtype.g:5224:7: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )?
+ int alt134=2;
+ int LA134_0 = input.LA(1);
+
+ if ( (LA134_0==RULE_ID||LA134_0==20||LA134_0==45) ) {
+ alt134=1;
+ }
+ switch (alt134) {
+ case 1 :
+ // InternalOXtype.g:5225:8: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )*
+ {
+ // InternalOXtype.g:5225:8: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:5226:9: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:5226:9: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:5227:10: ruleJvmFormalParameter
+ {
+ pushFollow(FOLLOW_47);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ // InternalOXtype.g:5230:8: ( ',' ( ( ruleJvmFormalParameter ) ) )*
+ loop133:
+ do {
+ int alt133=2;
+ int LA133_0 = input.LA(1);
+
+ if ( (LA133_0==21) ) {
+ alt133=1;
+ }
+
+
+ switch (alt133) {
+ case 1 :
+ // InternalOXtype.g:5231:9: ',' ( ( ruleJvmFormalParameter ) )
+ {
+ match(input,21,FOLLOW_26); if (state.failed) return ;
+ // InternalOXtype.g:5232:9: ( ( ruleJvmFormalParameter ) )
+ // InternalOXtype.g:5233:10: ( ruleJvmFormalParameter )
+ {
+ // InternalOXtype.g:5233:10: ( ruleJvmFormalParameter )
+ // InternalOXtype.g:5234:11: ruleJvmFormalParameter
+ {
+ pushFollow(FOLLOW_47);
+ ruleJvmFormalParameter();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop133;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ // InternalOXtype.g:5239:7: ( ( '|' ) )
+ // InternalOXtype.g:5240:8: ( '|' )
+ {
+ // InternalOXtype.g:5240:8: ( '|' )
+ // InternalOXtype.g:5241:9: '|'
+ {
+ match(input,62,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred41_InternalOXtype
+
+ // $ANTLR start synpred42_InternalOXtype
+ public final void synpred42_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:5318:4: ( ( () '[' ) )
+ // InternalOXtype.g:5318:5: ( () '[' )
+ {
+ // InternalOXtype.g:5318:5: ( () '[' )
+ // InternalOXtype.g:5319:5: () '['
+ {
+ // InternalOXtype.g:5319:5: ()
+ // InternalOXtype.g:5320:5:
+ {
+ }
+
+ match(input,25,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred42_InternalOXtype
+
+ // $ANTLR start synpred43_InternalOXtype
+ public final void synpred43_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:5661:4: ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )
+ // InternalOXtype.g:
+ {
+ if ( (input.LA(1)>=RULE_STRING && input.LA(1)<=RULE_ID)||(input.LA(1)>=13 && input.LA(1)<=15)||input.LA(1)==20||(input.LA(1)>=24 && input.LA(1)<=25)||input.LA(1)==32||(input.LA(1)>=48 && input.LA(1)<=49)||input.LA(1)==53||input.LA(1)==60||input.LA(1)==63||input.LA(1)==65||(input.LA(1)>=69 && input.LA(1)<=71)||(input.LA(1)>=74 && input.LA(1)<=83)||input.LA(1)==85 ) {
+ input.consume();
+ state.errorRecovery=false;state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred43_InternalOXtype
+
+ // $ANTLR start synpred44_InternalOXtype
+ public final void synpred44_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:5732:6: ( 'catch' )
+ // InternalOXtype.g:5732:7: 'catch'
+ {
+ match(input,86,FOLLOW_2); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred44_InternalOXtype
+
+ // $ANTLR start synpred45_InternalOXtype
+ public final void synpred45_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:5753:7: ( 'finally' )
+ // InternalOXtype.g:5753:8: 'finally'
+ {
+ match(input,84,FOLLOW_2); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred45_InternalOXtype
+
+ // $ANTLR start synpred48_InternalOXtype
+ public final void synpred48_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:5997:5: ( '.' )
+ // InternalOXtype.g:5997:6: '.'
+ {
+ match(input,57,FOLLOW_2); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred48_InternalOXtype
+
+ // $ANTLR start synpred49_InternalOXtype
+ public final void synpred49_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:6123:5: ( ( () ruleArrayBrackets ) )
+ // InternalOXtype.g:6123:6: ( () ruleArrayBrackets )
+ {
+ // InternalOXtype.g:6123:6: ( () ruleArrayBrackets )
+ // InternalOXtype.g:6124:6: () ruleArrayBrackets
+ {
+ // InternalOXtype.g:6124:6: ()
+ // InternalOXtype.g:6125:6:
+ {
+ }
+
+ pushFollow(FOLLOW_2);
+ ruleArrayBrackets();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred49_InternalOXtype
+
+ // $ANTLR start synpred50_InternalOXtype
+ public final void synpred50_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:6320:5: ( '<' )
+ // InternalOXtype.g:6320:6: '<'
+ {
+ match(input,32,FOLLOW_2); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred50_InternalOXtype
+
+ // $ANTLR start synpred51_InternalOXtype
+ public final void synpred51_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:6376:6: ( ( () '.' ) )
+ // InternalOXtype.g:6376:7: ( () '.' )
+ {
+ // InternalOXtype.g:6376:7: ( () '.' )
+ // InternalOXtype.g:6377:7: () '.'
+ {
+ // InternalOXtype.g:6377:7: ()
+ // InternalOXtype.g:6378:7:
+ {
+ }
+
+ match(input,57,FOLLOW_2); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred51_InternalOXtype
+
+ // $ANTLR start synpred52_InternalOXtype
+ public final void synpred52_InternalOXtype_fragment() throws RecognitionException {
+ // InternalOXtype.g:6414:7: ( '<' )
+ // InternalOXtype.g:6414:8: '<'
+ {
+ match(input,32,FOLLOW_2); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred52_InternalOXtype
+
+ // Delegated rules
+
+ public final boolean synpred35_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred35_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred48_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred48_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred22_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred22_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred8_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred8_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred19_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred19_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred13_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred13_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred9_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred9_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred39_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred39_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred52_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred52_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred43_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred43_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred26_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred26_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred10_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred10_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred15_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred15_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred23_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred23_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred31_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred31_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred49_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred49_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred36_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred36_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred18_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred18_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred44_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred44_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred14_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred14_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred27_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred27_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred40_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred40_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred1_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred1_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred16_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred16_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred33_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred33_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred20_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred20_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred32_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred32_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred37_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred37_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred45_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred45_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred24_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred24_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred5_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred5_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred11_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred11_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred41_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred41_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred7_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred7_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred42_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred42_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred2_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred2_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred17_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred17_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred21_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred21_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred50_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred50_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred25_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred25_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred51_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred51_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred38_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred38_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred6_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred6_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred29_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred29_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred12_InternalOXtype() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred12_InternalOXtype_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+
+
+ protected DFA3 dfa3 = new DFA3(this);
+ protected DFA6 dfa6 = new DFA6(this);
+ protected DFA12 dfa12 = new DFA12(this);
+ protected DFA15 dfa15 = new DFA15(this);
+ protected DFA17 dfa17 = new DFA17(this);
+ protected DFA27 dfa27 = new DFA27(this);
+ protected DFA30 dfa30 = new DFA30(this);
+ protected DFA46 dfa46 = new DFA46(this);
+ protected DFA45 dfa45 = new DFA45(this);
+ protected DFA47 dfa47 = new DFA47(this);
+ protected DFA49 dfa49 = new DFA49(this);
+ protected DFA58 dfa58 = new DFA58(this);
+ protected DFA65 dfa65 = new DFA65(this);
+ protected DFA64 dfa64 = new DFA64(this);
+ protected DFA87 dfa87 = new DFA87(this);
+ protected DFA86 dfa86 = new DFA86(this);
+ protected DFA88 dfa88 = new DFA88(this);
+ protected DFA92 dfa92 = new DFA92(this);
+ protected DFA95 dfa95 = new DFA95(this);
+ protected DFA94 dfa94 = new DFA94(this);
+ protected DFA96 dfa96 = new DFA96(this);
+ protected DFA99 dfa99 = new DFA99(this);
+ protected DFA117 dfa117 = new DFA117(this);
+ protected DFA115 dfa115 = new DFA115(this);
+ static final String dfa_1s = "\10\uffff";
+ static final String dfa_2s = "\2\uffff\1\5\3\uffff\1\5\1\uffff";
+ static final String dfa_3s = "\1\10\1\uffff\1\22\1\uffff\1\10\1\uffff\1\22\1\uffff";
+ static final String dfa_4s = "\1\21\1\uffff\1\71\1\uffff\1\20\1\uffff\1\71\1\uffff";
+ static final String dfa_5s = "\1\uffff\1\1\1\uffff\1\4\1\uffff\1\2\1\uffff\1\3";
+ static final String dfa_6s = "\10\uffff}>";
+ static final String[] dfa_7s = {
+ "\1\2\5\uffff\1\1\2\uffff\1\3",
+ "",
+ "\1\5\46\uffff\1\4",
+ "",
+ "\1\6\7\uffff\1\7",
+ "",
+ "\1\5\46\uffff\1\4",
+ ""
+ };
+
+ static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s);
+ static final short[] dfa_2 = DFA.unpackEncodedString(dfa_2s);
+ static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s);
+ static final char[] dfa_4 = DFA.unpackEncodedStringToUnsignedChars(dfa_4s);
+ static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s);
+ static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s);
+ static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s);
+
+ class DFA3 extends DFA {
+
+ public DFA3(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 3;
+ this.eot = dfa_1;
+ this.eof = dfa_2;
+ this.min = dfa_3;
+ this.max = dfa_4;
+ this.accept = dfa_5;
+ this.special = dfa_6;
+ this.transition = dfa_7;
+ }
+ public String getDescription() {
+ return "90:3: ( ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) ) | ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) ) )";
+ }
+ }
+ static final String dfa_8s = "\44\uffff";
+ static final String dfa_9s = "\1\4\1\0\42\uffff";
+ static final String dfa_10s = "\1\125\1\0\42\uffff";
+ static final String dfa_11s = "\2\uffff\1\2\37\uffff\1\3\1\1";
+ static final String dfa_12s = "\1\uffff\1\0\42\uffff}>";
+ static final String[] dfa_13s = {
+ "\4\2\1\1\4\uffff\3\2\3\uffff\2\2\1\uffff\1\42\1\uffff\2\2\6\uffff\1\2\17\uffff\2\2\3\uffff\1\2\6\uffff\1\2\2\uffff\1\2\1\uffff\1\2\3\uffff\3\2\2\uffff\12\2\1\uffff\1\2",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] dfa_8 = DFA.unpackEncodedString(dfa_8s);
+ static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s);
+ static final char[] dfa_10 = DFA.unpackEncodedStringToUnsignedChars(dfa_10s);
+ static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s);
+ static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s);
+ static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s);
+
+ class DFA6 extends DFA {
+
+ public DFA6(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 6;
+ this.eot = dfa_8;
+ this.eof = dfa_8;
+ this.min = dfa_9;
+ this.max = dfa_10;
+ this.accept = dfa_11;
+ this.special = dfa_12;
+ this.transition = dfa_13;
+ }
+ public String getDescription() {
+ return "307:4: ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA6_1 = input.LA(1);
+
+
+ int index6_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred2_InternalOXtype()) ) {s = 35;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index6_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 6, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_14s = "\43\uffff";
+ static final String dfa_15s = "\1\4\1\0\41\uffff";
+ static final String dfa_16s = "\1\125\1\0\41\uffff";
+ static final String dfa_17s = "\2\uffff\1\2\37\uffff\1\1";
+ static final String dfa_18s = "\1\uffff\1\0\41\uffff}>";
+ static final String[] dfa_19s = {
+ "\5\2\4\uffff\3\2\3\uffff\2\2\3\uffff\1\1\1\2\6\uffff\1\2\17\uffff\2\2\3\uffff\1\2\6\uffff\1\2\2\uffff\1\2\1\uffff\1\2\3\uffff\3\2\2\uffff\12\2\1\uffff\1\2",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] dfa_14 = DFA.unpackEncodedString(dfa_14s);
+ static final char[] dfa_15 = DFA.unpackEncodedStringToUnsignedChars(dfa_15s);
+ static final char[] dfa_16 = DFA.unpackEncodedStringToUnsignedChars(dfa_16s);
+ static final short[] dfa_17 = DFA.unpackEncodedString(dfa_17s);
+ static final short[] dfa_18 = DFA.unpackEncodedString(dfa_18s);
+ static final short[][] dfa_19 = unpackEncodedStringArray(dfa_19s);
+
+ class DFA12 extends DFA {
+
+ public DFA12(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 12;
+ this.eot = dfa_14;
+ this.eof = dfa_14;
+ this.min = dfa_15;
+ this.max = dfa_16;
+ this.accept = dfa_17;
+ this.special = dfa_18;
+ this.transition = dfa_19;
+ }
+ public String getDescription() {
+ return "487:2: ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | (this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )? ) )";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA12_1 = input.LA(1);
+
+
+ int index12_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred5_InternalOXtype()) ) {s = 34;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index12_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 12, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+ class DFA15 extends DFA {
+
+ public DFA15(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 15;
+ this.eot = dfa_14;
+ this.eof = dfa_14;
+ this.min = dfa_15;
+ this.max = dfa_16;
+ this.accept = dfa_17;
+ this.special = dfa_18;
+ this.transition = dfa_19;
+ }
+ public String getDescription() {
+ return "629:2: ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression )";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA15_1 = input.LA(1);
+
+
+ int index15_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred6_InternalOXtype()) ) {s = 34;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index15_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 15, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_20s = "\12\uffff";
+ static final String dfa_21s = "\1\10\11\uffff";
+ static final String dfa_22s = "\1\4\7\0\2\uffff";
+ static final String dfa_23s = "\1\126\7\0\2\uffff";
+ static final String dfa_24s = "\10\uffff\1\2\1\1";
+ static final String dfa_25s = "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\2\uffff}>";
+ static final String[] dfa_26s = {
+ "\5\10\4\uffff\4\10\1\uffff\1\10\1\uffff\3\10\1\uffff\3\10\1\1\1\2\1\3\1\4\1\5\1\6\1\7\34\10\1\uffff\30\10",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ ""
+ };
+
+ static final short[] dfa_20 = DFA.unpackEncodedString(dfa_20s);
+ static final short[] dfa_21 = DFA.unpackEncodedString(dfa_21s);
+ static final char[] dfa_22 = DFA.unpackEncodedStringToUnsignedChars(dfa_22s);
+ static final char[] dfa_23 = DFA.unpackEncodedStringToUnsignedChars(dfa_23s);
+ static final short[] dfa_24 = DFA.unpackEncodedString(dfa_24s);
+ static final short[] dfa_25 = DFA.unpackEncodedString(dfa_25s);
+ static final short[][] dfa_26 = unpackEncodedStringArray(dfa_26s);
+
+ class DFA17 extends DFA {
+
+ public DFA17(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 17;
+ this.eot = dfa_20;
+ this.eof = dfa_21;
+ this.min = dfa_22;
+ this.max = dfa_23;
+ this.accept = dfa_24;
+ this.special = dfa_25;
+ this.transition = dfa_26;
+ }
+ public String getDescription() {
+ return "858:4: ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA17_1 = input.LA(1);
+
+
+ int index17_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred7_InternalOXtype()) ) {s = 9;}
+
+ else if ( (true) ) {s = 8;}
+
+
+ input.seek(index17_1);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA17_2 = input.LA(1);
+
+
+ int index17_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred7_InternalOXtype()) ) {s = 9;}
+
+ else if ( (true) ) {s = 8;}
+
+
+ input.seek(index17_2);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA17_3 = input.LA(1);
+
+
+ int index17_3 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred7_InternalOXtype()) ) {s = 9;}
+
+ else if ( (true) ) {s = 8;}
+
+
+ input.seek(index17_3);
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA17_4 = input.LA(1);
+
+
+ int index17_4 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred7_InternalOXtype()) ) {s = 9;}
+
+ else if ( (true) ) {s = 8;}
+
+
+ input.seek(index17_4);
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA17_5 = input.LA(1);
+
+
+ int index17_5 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred7_InternalOXtype()) ) {s = 9;}
+
+ else if ( (true) ) {s = 8;}
+
+
+ input.seek(index17_5);
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA17_6 = input.LA(1);
+
+
+ int index17_6 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred7_InternalOXtype()) ) {s = 9;}
+
+ else if ( (true) ) {s = 8;}
+
+
+ input.seek(index17_6);
+ if ( s>=0 ) return s;
+ break;
+ case 6 :
+ int LA17_7 = input.LA(1);
+
+
+ int index17_7 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred7_InternalOXtype()) ) {s = 9;}
+
+ else if ( (true) ) {s = 8;}
+
+
+ input.seek(index17_7);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 17, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_27s = "\13\uffff";
+ static final String dfa_28s = "\1\1\12\uffff";
+ static final String dfa_29s = "\1\4\1\uffff\10\0\1\uffff";
+ static final String dfa_30s = "\1\126\1\uffff\10\0\1\uffff";
+ static final String dfa_31s = "\1\uffff\1\2\10\uffff\1\1";
+ static final String dfa_32s = "\2\uffff\1\3\1\5\1\0\1\1\1\4\1\2\1\6\1\7\1\uffff}>";
+ static final String[] dfa_33s = {
+ "\5\1\4\uffff\4\1\1\uffff\1\1\1\uffff\3\1\1\uffff\10\1\1\2\1\3\10\1\1\4\1\5\1\6\1\7\1\10\1\11\16\1\1\uffff\30\1",
+ "",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ ""
+ };
+
+ static final short[] dfa_27 = DFA.unpackEncodedString(dfa_27s);
+ static final short[] dfa_28 = DFA.unpackEncodedString(dfa_28s);
+ static final char[] dfa_29 = DFA.unpackEncodedStringToUnsignedChars(dfa_29s);
+ static final char[] dfa_30 = DFA.unpackEncodedStringToUnsignedChars(dfa_30s);
+ static final short[] dfa_31 = DFA.unpackEncodedString(dfa_31s);
+ static final short[] dfa_32 = DFA.unpackEncodedString(dfa_32s);
+ static final short[][] dfa_33 = unpackEncodedStringArray(dfa_33s);
+
+ class DFA27 extends DFA {
+
+ public DFA27(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 27;
+ this.eot = dfa_27;
+ this.eof = dfa_28;
+ this.min = dfa_29;
+ this.max = dfa_30;
+ this.accept = dfa_31;
+ this.special = dfa_32;
+ this.transition = dfa_33;
+ }
+ public String getDescription() {
+ return "()* loopback of 1572:3: ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )*";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA27_4 = input.LA(1);
+
+
+ int index27_4 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred13_InternalOXtype()) ) {s = 10;}
+
+ else if ( (true) ) {s = 1;}
+
+
+ input.seek(index27_4);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA27_5 = input.LA(1);
+
+
+ int index27_5 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred13_InternalOXtype()) ) {s = 10;}
+
+ else if ( (true) ) {s = 1;}
+
+
+ input.seek(index27_5);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA27_7 = input.LA(1);
+
+
+ int index27_7 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred13_InternalOXtype()) ) {s = 10;}
+
+ else if ( (true) ) {s = 1;}
+
+
+ input.seek(index27_7);
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA27_2 = input.LA(1);
+
+
+ int index27_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred13_InternalOXtype()) ) {s = 10;}
+
+ else if ( (true) ) {s = 1;}
+
+
+ input.seek(index27_2);
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA27_6 = input.LA(1);
+
+
+ int index27_6 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred13_InternalOXtype()) ) {s = 10;}
+
+ else if ( (true) ) {s = 1;}
+
+
+ input.seek(index27_6);
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA27_3 = input.LA(1);
+
+
+ int index27_3 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred13_InternalOXtype()) ) {s = 10;}
+
+ else if ( (true) ) {s = 1;}
+
+
+ input.seek(index27_3);
+ if ( s>=0 ) return s;
+ break;
+ case 6 :
+ int LA27_8 = input.LA(1);
+
+
+ int index27_8 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred13_InternalOXtype()) ) {s = 10;}
+
+ else if ( (true) ) {s = 1;}
+
+
+ input.seek(index27_8);
+ if ( s>=0 ) return s;
+ break;
+ case 7 :
+ int LA27_9 = input.LA(1);
+
+
+ int index27_9 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred13_InternalOXtype()) ) {s = 10;}
+
+ else if ( (true) ) {s = 1;}
+
+
+ input.seek(index27_9);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 27, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_34s = "\1\40\2\uffff\1\41\7\uffff";
+ static final String dfa_35s = "\1\57\2\uffff\1\54\7\uffff";
+ static final String dfa_36s = "\1\uffff\1\1\1\2\1\uffff\1\4\1\5\1\7\1\10\1\11\1\3\1\6";
+ static final String dfa_37s = "\13\uffff}>";
+ static final String[] dfa_38s = {
+ "\1\6\1\3\10\uffff\1\1\1\2\1\4\1\5\1\7\1\10",
+ "",
+ "",
+ "\1\12\12\uffff\1\11",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+ static final char[] dfa_34 = DFA.unpackEncodedStringToUnsignedChars(dfa_34s);
+ static final char[] dfa_35 = DFA.unpackEncodedStringToUnsignedChars(dfa_35s);
+ static final short[] dfa_36 = DFA.unpackEncodedString(dfa_36s);
+ static final short[] dfa_37 = DFA.unpackEncodedString(dfa_37s);
+ static final short[][] dfa_38 = unpackEncodedStringArray(dfa_38s);
+
+ class DFA30 extends DFA {
+
+ public DFA30(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 30;
+ this.eot = dfa_27;
+ this.eof = dfa_27;
+ this.min = dfa_34;
+ this.max = dfa_35;
+ this.accept = dfa_36;
+ this.special = dfa_37;
+ this.transition = dfa_38;
+ }
+ public String getDescription() {
+ return "1648:2: (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' )";
+ }
+ }
+ static final String dfa_39s = "\116\uffff";
+ static final String dfa_40s = "\1\2\115\uffff";
+ static final String dfa_41s = "\1\4\1\0\114\uffff";
+ static final String dfa_42s = "\1\126\1\0\114\uffff";
+ static final String dfa_43s = "\2\uffff\1\2\112\uffff\1\1";
+ static final String dfa_44s = "\1\uffff\1\0\114\uffff}>";
+ static final String[] dfa_45s = {
+ "\5\2\4\uffff\4\2\1\uffff\1\2\1\uffff\1\1\2\2\1\uffff\46\2\1\uffff\30\2",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] dfa_39 = DFA.unpackEncodedString(dfa_39s);
+ static final short[] dfa_40 = DFA.unpackEncodedString(dfa_40s);
+ static final char[] dfa_41 = DFA.unpackEncodedStringToUnsignedChars(dfa_41s);
+ static final char[] dfa_42 = DFA.unpackEncodedStringToUnsignedChars(dfa_42s);
+ static final short[] dfa_43 = DFA.unpackEncodedString(dfa_43s);
+ static final short[] dfa_44 = DFA.unpackEncodedString(dfa_44s);
+ static final short[][] dfa_45 = unpackEncodedStringArray(dfa_45s);
+
+ class DFA46 extends DFA {
+
+ public DFA46(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 46;
+ this.eot = dfa_39;
+ this.eof = dfa_40;
+ this.min = dfa_41;
+ this.max = dfa_42;
+ this.accept = dfa_43;
+ this.special = dfa_44;
+ this.transition = dfa_45;
+ }
+ public String getDescription() {
+ return "2549:5: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA46_1 = input.LA(1);
+
+
+ int index46_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred22_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index46_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 46, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_46s = "\1\4\2\0\41\uffff";
+ static final String dfa_47s = "\1\125\2\0\41\uffff";
+ static final String dfa_48s = "\3\uffff\2\1\1\2\35\uffff\1\3";
+ static final String dfa_49s = "\1\0\1\1\1\2\41\uffff}>";
+ static final String[] dfa_50s = {
+ "\4\5\1\1\4\uffff\3\5\4\uffff\1\2\1\uffff\1\43\1\uffff\2\5\6\uffff\1\5\14\uffff\1\3\2\uffff\2\5\3\uffff\1\5\6\uffff\1\5\1\uffff\1\4\1\5\1\uffff\1\5\3\uffff\3\5\2\uffff\12\5\1\uffff\1\5",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+ static final char[] dfa_46 = DFA.unpackEncodedStringToUnsignedChars(dfa_46s);
+ static final char[] dfa_47 = DFA.unpackEncodedStringToUnsignedChars(dfa_47s);
+ static final short[] dfa_48 = DFA.unpackEncodedString(dfa_48s);
+ static final short[] dfa_49 = DFA.unpackEncodedString(dfa_49s);
+ static final short[][] dfa_50 = unpackEncodedStringArray(dfa_50s);
+
+ class DFA45 extends DFA {
+
+ public DFA45(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 45;
+ this.eot = dfa_8;
+ this.eof = dfa_8;
+ this.min = dfa_46;
+ this.max = dfa_47;
+ this.accept = dfa_48;
+ this.special = dfa_49;
+ this.transition = dfa_50;
+ }
+ public String getDescription() {
+ return "2568:6: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA45_0 = input.LA(1);
+
+
+ int index45_0 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (LA45_0==RULE_ID) ) {s = 1;}
+
+ else if ( (LA45_0==20) ) {s = 2;}
+
+ else if ( (LA45_0==45) && (synpred23_InternalOXtype())) {s = 3;}
+
+ else if ( (LA45_0==62) && (synpred23_InternalOXtype())) {s = 4;}
+
+ else if ( ((LA45_0>=RULE_STRING && LA45_0<=RULE_DECIMAL)||(LA45_0>=13 && LA45_0<=15)||(LA45_0>=24 && LA45_0<=25)||LA45_0==32||(LA45_0>=48 && LA45_0<=49)||LA45_0==53||LA45_0==60||LA45_0==63||LA45_0==65||(LA45_0>=69 && LA45_0<=71)||(LA45_0>=74 && LA45_0<=83)||LA45_0==85) ) {s = 5;}
+
+ else if ( (LA45_0==22) ) {s = 35;}
+
+
+ input.seek(index45_0);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA45_1 = input.LA(1);
+
+
+ int index45_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred23_InternalOXtype()) ) {s = 4;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index45_1);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA45_2 = input.LA(1);
+
+
+ int index45_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred23_InternalOXtype()) ) {s = 4;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index45_2);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 45, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String[] dfa_51s = {
+ "\5\2\4\uffff\4\2\1\uffff\1\2\1\uffff\3\2\1\uffff\1\2\1\1\44\2\1\uffff\30\2",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+ static final short[][] dfa_51 = unpackEncodedStringArray(dfa_51s);
+
+ class DFA47 extends DFA {
+
+ public DFA47(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 47;
+ this.eot = dfa_39;
+ this.eof = dfa_40;
+ this.min = dfa_41;
+ this.max = dfa_42;
+ this.accept = dfa_43;
+ this.special = dfa_44;
+ this.transition = dfa_51;
+ }
+ public String getDescription() {
+ return "2666:5: ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA47_1 = input.LA(1);
+
+
+ int index47_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred24_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index47_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 47, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_52s = "\40\uffff";
+ static final String dfa_53s = "\1\4\26\uffff\1\0\10\uffff";
+ static final String dfa_54s = "\1\125\26\uffff\1\0\10\uffff";
+ static final String dfa_55s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\6\uffff\1\6\11\uffff\1\7\1\uffff\1\12\1\13\1\14\1\15\1\16\1\17\1\10\1\11";
+ static final String dfa_56s = "\1\0\26\uffff\1\1\10\uffff}>";
+ static final String[] dfa_57s = {
+ "\4\14\1\5\4\uffff\3\5\4\uffff\1\35\3\uffff\2\14\6\uffff\1\5\33\uffff\1\2\2\uffff\1\26\1\uffff\1\3\3\uffff\1\27\1\30\1\31\2\uffff\2\5\1\1\4\14\1\32\1\33\1\34\1\uffff\1\4",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] dfa_52 = DFA.unpackEncodedString(dfa_52s);
+ static final char[] dfa_53 = DFA.unpackEncodedStringToUnsignedChars(dfa_53s);
+ static final char[] dfa_54 = DFA.unpackEncodedStringToUnsignedChars(dfa_54s);
+ static final short[] dfa_55 = DFA.unpackEncodedString(dfa_55s);
+ static final short[] dfa_56 = DFA.unpackEncodedString(dfa_56s);
+ static final short[][] dfa_57 = unpackEncodedStringArray(dfa_57s);
+
+ class DFA49 extends DFA {
+
+ public DFA49(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 49;
+ this.eot = dfa_52;
+ this.eof = dfa_52;
+ this.min = dfa_53;
+ this.max = dfa_54;
+ this.accept = dfa_55;
+ this.special = dfa_56;
+ this.transition = dfa_57;
+ }
+ public String getDescription() {
+ return "2711:2: (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression )";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA49_0 = input.LA(1);
+
+
+ int index49_0 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (LA49_0==76) ) {s = 1;}
+
+ else if ( (LA49_0==60) ) {s = 2;}
+
+ else if ( (LA49_0==65) ) {s = 3;}
+
+ else if ( (LA49_0==85) && (synpred25_InternalOXtype())) {s = 4;}
+
+ else if ( (LA49_0==RULE_ID||(LA49_0>=13 && LA49_0<=15)||LA49_0==32||(LA49_0>=74 && LA49_0<=75)) ) {s = 5;}
+
+ else if ( ((LA49_0>=RULE_STRING && LA49_0<=RULE_DECIMAL)||(LA49_0>=24 && LA49_0<=25)||(LA49_0>=77 && LA49_0<=80)) ) {s = 12;}
+
+ else if ( (LA49_0==63) ) {s = 22;}
+
+ else if ( (LA49_0==69) ) {s = 23;}
+
+ else if ( (LA49_0==70) ) {s = 24;}
+
+ else if ( (LA49_0==71) ) {s = 25;}
+
+ else if ( (LA49_0==81) ) {s = 26;}
+
+ else if ( (LA49_0==82) ) {s = 27;}
+
+ else if ( (LA49_0==83) ) {s = 28;}
+
+ else if ( (LA49_0==20) ) {s = 29;}
+
+
+ input.seek(index49_0);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA49_23 = input.LA(1);
+
+
+ int index49_23 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred26_InternalOXtype()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index49_23);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 49, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_58s = "\46\uffff";
+ static final String dfa_59s = "\1\4\2\0\43\uffff";
+ static final String dfa_60s = "\1\125\2\0\43\uffff";
+ static final String dfa_61s = "\3\uffff\2\1\1\2\40\uffff";
+ static final String dfa_62s = "\1\0\1\1\1\2\43\uffff}>";
+ static final String[] dfa_63s = {
+ "\4\5\1\1\4\uffff\3\5\4\uffff\1\2\3\uffff\3\5\5\uffff\1\5\14\uffff\1\3\2\uffff\2\5\3\uffff\1\5\6\uffff\1\5\1\uffff\1\4\1\5\1\uffff\1\5\3\uffff\17\5\1\uffff\1\5",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] dfa_58 = DFA.unpackEncodedString(dfa_58s);
+ static final char[] dfa_59 = DFA.unpackEncodedStringToUnsignedChars(dfa_59s);
+ static final char[] dfa_60 = DFA.unpackEncodedStringToUnsignedChars(dfa_60s);
+ static final short[] dfa_61 = DFA.unpackEncodedString(dfa_61s);
+ static final short[] dfa_62 = DFA.unpackEncodedString(dfa_62s);
+ static final short[][] dfa_63 = unpackEncodedStringArray(dfa_63s);
+
+ class DFA58 extends DFA {
+
+ public DFA58(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 58;
+ this.eot = dfa_58;
+ this.eof = dfa_58;
+ this.min = dfa_59;
+ this.max = dfa_60;
+ this.accept = dfa_61;
+ this.special = dfa_62;
+ this.transition = dfa_63;
+ }
+ public String getDescription() {
+ return "3203:3: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA58_0 = input.LA(1);
+
+
+ int index58_0 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (LA58_0==RULE_ID) ) {s = 1;}
+
+ else if ( (LA58_0==20) ) {s = 2;}
+
+ else if ( (LA58_0==45) && (synpred29_InternalOXtype())) {s = 3;}
+
+ else if ( (LA58_0==62) && (synpred29_InternalOXtype())) {s = 4;}
+
+ else if ( ((LA58_0>=RULE_STRING && LA58_0<=RULE_DECIMAL)||(LA58_0>=13 && LA58_0<=15)||(LA58_0>=24 && LA58_0<=26)||LA58_0==32||(LA58_0>=48 && LA58_0<=49)||LA58_0==53||LA58_0==60||LA58_0==63||LA58_0==65||(LA58_0>=69 && LA58_0<=83)||LA58_0==85) ) {s = 5;}
+
+
+ input.seek(index58_0);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA58_1 = input.LA(1);
+
+
+ int index58_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred29_InternalOXtype()) ) {s = 4;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index58_1);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA58_2 = input.LA(1);
+
+
+ int index58_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred29_InternalOXtype()) ) {s = 4;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index58_2);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 58, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String[] dfa_64s = {
+ "\5\2\4\uffff\3\2\4\uffff\1\1\3\uffff\2\2\6\uffff\1\2\14\uffff\1\2\2\uffff\2\2\3\uffff\1\2\6\uffff\1\2\2\uffff\1\2\1\uffff\1\2\3\uffff\3\2\2\uffff\12\2\1\uffff\1\2",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+ static final short[][] dfa_64 = unpackEncodedStringArray(dfa_64s);
+
+ class DFA65 extends DFA {
+
+ public DFA65(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 65;
+ this.eot = dfa_14;
+ this.eof = dfa_14;
+ this.min = dfa_15;
+ this.max = dfa_16;
+ this.accept = dfa_17;
+ this.special = dfa_18;
+ this.transition = dfa_64;
+ }
+ public String getDescription() {
+ return "3669:3: ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) )";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA65_1 = input.LA(1);
+
+
+ int index65_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred32_InternalOXtype()) ) {s = 34;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index65_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 65, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_65s = "\42\uffff";
+ static final String dfa_66s = "\1\4\2\0\37\uffff";
+ static final String dfa_67s = "\1\125\2\0\37\uffff";
+ static final String dfa_68s = "\3\uffff\1\1\1\2\35\uffff";
+ static final String dfa_69s = "\1\0\1\1\1\2\37\uffff}>";
+ static final String[] dfa_70s = {
+ "\4\4\1\1\4\uffff\3\4\4\uffff\1\2\3\uffff\2\4\6\uffff\1\4\14\uffff\1\3\2\uffff\2\4\3\uffff\1\4\6\uffff\1\4\2\uffff\1\4\1\uffff\1\4\3\uffff\3\4\2\uffff\12\4\1\uffff\1\4",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] dfa_65 = DFA.unpackEncodedString(dfa_65s);
+ static final char[] dfa_66 = DFA.unpackEncodedStringToUnsignedChars(dfa_66s);
+ static final char[] dfa_67 = DFA.unpackEncodedStringToUnsignedChars(dfa_67s);
+ static final short[] dfa_68 = DFA.unpackEncodedString(dfa_68s);
+ static final short[] dfa_69 = DFA.unpackEncodedString(dfa_69s);
+ static final short[][] dfa_70 = unpackEncodedStringArray(dfa_70s);
+
+ class DFA64 extends DFA {
+
+ public DFA64(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 64;
+ this.eot = dfa_65;
+ this.eof = dfa_65;
+ this.min = dfa_66;
+ this.max = dfa_67;
+ this.accept = dfa_68;
+ this.special = dfa_69;
+ this.transition = dfa_70;
+ }
+ public String getDescription() {
+ return "3738:5: ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA64_0 = input.LA(1);
+
+
+ int index64_0 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (LA64_0==RULE_ID) ) {s = 1;}
+
+ else if ( (LA64_0==20) ) {s = 2;}
+
+ else if ( (LA64_0==45) && (synpred33_InternalOXtype())) {s = 3;}
+
+ else if ( ((LA64_0>=RULE_STRING && LA64_0<=RULE_DECIMAL)||(LA64_0>=13 && LA64_0<=15)||(LA64_0>=24 && LA64_0<=25)||LA64_0==32||(LA64_0>=48 && LA64_0<=49)||LA64_0==53||LA64_0==60||LA64_0==63||LA64_0==65||(LA64_0>=69 && LA64_0<=71)||(LA64_0>=74 && LA64_0<=83)||LA64_0==85) ) {s = 4;}
+
+
+ input.seek(index64_0);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA64_1 = input.LA(1);
+
+
+ int index64_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred33_InternalOXtype()) ) {s = 3;}
+
+ else if ( (true) ) {s = 4;}
+
+
+ input.seek(index64_1);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA64_2 = input.LA(1);
+
+
+ int index64_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred33_InternalOXtype()) ) {s = 3;}
+
+ else if ( (true) ) {s = 4;}
+
+
+ input.seek(index64_2);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 64, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+ class DFA87 extends DFA {
+
+ public DFA87(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 87;
+ this.eot = dfa_39;
+ this.eof = dfa_40;
+ this.min = dfa_41;
+ this.max = dfa_42;
+ this.accept = dfa_43;
+ this.special = dfa_44;
+ this.transition = dfa_45;
+ }
+ public String getDescription() {
+ return "4867:3: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA87_1 = input.LA(1);
+
+
+ int index87_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index87_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 87, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+ class DFA86 extends DFA {
+
+ public DFA86(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 86;
+ this.eot = dfa_8;
+ this.eof = dfa_8;
+ this.min = dfa_46;
+ this.max = dfa_47;
+ this.accept = dfa_48;
+ this.special = dfa_49;
+ this.transition = dfa_50;
+ }
+ public String getDescription() {
+ return "4886:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA86_0 = input.LA(1);
+
+
+ int index86_0 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (LA86_0==RULE_ID) ) {s = 1;}
+
+ else if ( (LA86_0==20) ) {s = 2;}
+
+ else if ( (LA86_0==45) && (synpred37_InternalOXtype())) {s = 3;}
+
+ else if ( (LA86_0==62) && (synpred37_InternalOXtype())) {s = 4;}
+
+ else if ( ((LA86_0>=RULE_STRING && LA86_0<=RULE_DECIMAL)||(LA86_0>=13 && LA86_0<=15)||(LA86_0>=24 && LA86_0<=25)||LA86_0==32||(LA86_0>=48 && LA86_0<=49)||LA86_0==53||LA86_0==60||LA86_0==63||LA86_0==65||(LA86_0>=69 && LA86_0<=71)||(LA86_0>=74 && LA86_0<=83)||LA86_0==85) ) {s = 5;}
+
+ else if ( (LA86_0==22) ) {s = 35;}
+
+
+ input.seek(index86_0);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA86_1 = input.LA(1);
+
+
+ int index86_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred37_InternalOXtype()) ) {s = 4;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index86_1);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA86_2 = input.LA(1);
+
+
+ int index86_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred37_InternalOXtype()) ) {s = 4;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index86_2);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 86, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+ class DFA88 extends DFA {
+
+ public DFA88(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 88;
+ this.eot = dfa_39;
+ this.eof = dfa_40;
+ this.min = dfa_41;
+ this.max = dfa_42;
+ this.accept = dfa_43;
+ this.special = dfa_44;
+ this.transition = dfa_51;
+ }
+ public String getDescription() {
+ return "4984:3: ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA88_1 = input.LA(1);
+
+
+ int index88_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred38_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index88_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 88, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String[] dfa_71s = {
+ "\5\2\4\uffff\4\2\1\uffff\1\2\1\uffff\3\2\1\uffff\10\2\1\1\35\2\1\uffff\30\2",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+ static final short[][] dfa_71 = unpackEncodedStringArray(dfa_71s);
+
+ class DFA92 extends DFA {
+
+ public DFA92(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 92;
+ this.eot = dfa_39;
+ this.eof = dfa_40;
+ this.min = dfa_41;
+ this.max = dfa_42;
+ this.accept = dfa_43;
+ this.special = dfa_44;
+ this.transition = dfa_71;
+ }
+ public String getDescription() {
+ return "5143:3: ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA92_1 = input.LA(1);
+
+
+ int index92_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred39_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index92_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 92, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+ class DFA95 extends DFA {
+
+ public DFA95(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 95;
+ this.eot = dfa_39;
+ this.eof = dfa_40;
+ this.min = dfa_41;
+ this.max = dfa_42;
+ this.accept = dfa_43;
+ this.special = dfa_44;
+ this.transition = dfa_45;
+ }
+ public String getDescription() {
+ return "5200:3: ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA95_1 = input.LA(1);
+
+
+ int index95_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred40_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index95_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 95, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+ class DFA94 extends DFA {
+
+ public DFA94(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 94;
+ this.eot = dfa_8;
+ this.eof = dfa_8;
+ this.min = dfa_46;
+ this.max = dfa_47;
+ this.accept = dfa_48;
+ this.special = dfa_49;
+ this.transition = dfa_50;
+ }
+ public String getDescription() {
+ return "5219:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA94_0 = input.LA(1);
+
+
+ int index94_0 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (LA94_0==RULE_ID) ) {s = 1;}
+
+ else if ( (LA94_0==20) ) {s = 2;}
+
+ else if ( (LA94_0==45) && (synpred41_InternalOXtype())) {s = 3;}
+
+ else if ( (LA94_0==62) && (synpred41_InternalOXtype())) {s = 4;}
+
+ else if ( ((LA94_0>=RULE_STRING && LA94_0<=RULE_DECIMAL)||(LA94_0>=13 && LA94_0<=15)||(LA94_0>=24 && LA94_0<=25)||LA94_0==32||(LA94_0>=48 && LA94_0<=49)||LA94_0==53||LA94_0==60||LA94_0==63||LA94_0==65||(LA94_0>=69 && LA94_0<=71)||(LA94_0>=74 && LA94_0<=83)||LA94_0==85) ) {s = 5;}
+
+ else if ( (LA94_0==22) ) {s = 35;}
+
+
+ input.seek(index94_0);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA94_1 = input.LA(1);
+
+
+ int index94_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred41_InternalOXtype()) ) {s = 4;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index94_1);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA94_2 = input.LA(1);
+
+
+ int index94_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred41_InternalOXtype()) ) {s = 4;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index94_2);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 94, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+ class DFA96 extends DFA {
+
+ public DFA96(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 96;
+ this.eot = dfa_39;
+ this.eof = dfa_40;
+ this.min = dfa_41;
+ this.max = dfa_42;
+ this.accept = dfa_43;
+ this.special = dfa_44;
+ this.transition = dfa_51;
+ }
+ public String getDescription() {
+ return "5317:3: ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA96_1 = input.LA(1);
+
+
+ int index96_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred42_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index96_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 96, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_72s = "\1\41\115\uffff";
+ static final String dfa_73s = "\1\4\40\0\55\uffff";
+ static final String dfa_74s = "\1\126\40\0\55\uffff";
+ static final String dfa_75s = "\41\uffff\1\2\53\uffff\1\1";
+ static final String dfa_76s = "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35\1\36\1\37\55\uffff}>";
+ static final String[] dfa_77s = {
+ "\1\27\1\23\1\24\1\25\1\1\4\uffff\1\4\1\3\1\5\1\41\1\uffff\1\41\1\uffff\1\40\2\41\1\uffff\1\17\1\20\6\41\1\15\17\41\1\10\1\7\3\41\1\6\6\41\1\12\1\41\1\uffff\1\31\1\41\1\13\3\41\1\32\1\33\1\34\2\41\1\2\1\16\1\11\1\21\1\22\1\26\1\30\1\35\1\36\1\37\1\41\1\14\1\41",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+ static final short[] dfa_72 = DFA.unpackEncodedString(dfa_72s);
+ static final char[] dfa_73 = DFA.unpackEncodedStringToUnsignedChars(dfa_73s);
+ static final char[] dfa_74 = DFA.unpackEncodedStringToUnsignedChars(dfa_74s);
+ static final short[] dfa_75 = DFA.unpackEncodedString(dfa_75s);
+ static final short[] dfa_76 = DFA.unpackEncodedString(dfa_76s);
+ static final short[][] dfa_77 = unpackEncodedStringArray(dfa_77s);
+
+ class DFA99 extends DFA {
+
+ public DFA99(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 99;
+ this.eot = dfa_39;
+ this.eof = dfa_72;
+ this.min = dfa_73;
+ this.max = dfa_74;
+ this.accept = dfa_75;
+ this.special = dfa_76;
+ this.transition = dfa_77;
+ }
+ public String getDescription() {
+ return "5660:3: ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA99_1 = input.LA(1);
+
+
+ int index99_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_1);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA99_2 = input.LA(1);
+
+
+ int index99_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_2);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA99_3 = input.LA(1);
+
+
+ int index99_3 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_3);
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA99_4 = input.LA(1);
+
+
+ int index99_4 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_4);
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA99_5 = input.LA(1);
+
+
+ int index99_5 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_5);
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA99_6 = input.LA(1);
+
+
+ int index99_6 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_6);
+ if ( s>=0 ) return s;
+ break;
+ case 6 :
+ int LA99_7 = input.LA(1);
+
+
+ int index99_7 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_7);
+ if ( s>=0 ) return s;
+ break;
+ case 7 :
+ int LA99_8 = input.LA(1);
+
+
+ int index99_8 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_8);
+ if ( s>=0 ) return s;
+ break;
+ case 8 :
+ int LA99_9 = input.LA(1);
+
+
+ int index99_9 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_9);
+ if ( s>=0 ) return s;
+ break;
+ case 9 :
+ int LA99_10 = input.LA(1);
+
+
+ int index99_10 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_10);
+ if ( s>=0 ) return s;
+ break;
+ case 10 :
+ int LA99_11 = input.LA(1);
+
+
+ int index99_11 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_11);
+ if ( s>=0 ) return s;
+ break;
+ case 11 :
+ int LA99_12 = input.LA(1);
+
+
+ int index99_12 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_12);
+ if ( s>=0 ) return s;
+ break;
+ case 12 :
+ int LA99_13 = input.LA(1);
+
+
+ int index99_13 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_13);
+ if ( s>=0 ) return s;
+ break;
+ case 13 :
+ int LA99_14 = input.LA(1);
+
+
+ int index99_14 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_14);
+ if ( s>=0 ) return s;
+ break;
+ case 14 :
+ int LA99_15 = input.LA(1);
+
+
+ int index99_15 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_15);
+ if ( s>=0 ) return s;
+ break;
+ case 15 :
+ int LA99_16 = input.LA(1);
+
+
+ int index99_16 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_16);
+ if ( s>=0 ) return s;
+ break;
+ case 16 :
+ int LA99_17 = input.LA(1);
+
+
+ int index99_17 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_17);
+ if ( s>=0 ) return s;
+ break;
+ case 17 :
+ int LA99_18 = input.LA(1);
+
+
+ int index99_18 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_18);
+ if ( s>=0 ) return s;
+ break;
+ case 18 :
+ int LA99_19 = input.LA(1);
+
+
+ int index99_19 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_19);
+ if ( s>=0 ) return s;
+ break;
+ case 19 :
+ int LA99_20 = input.LA(1);
+
+
+ int index99_20 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_20);
+ if ( s>=0 ) return s;
+ break;
+ case 20 :
+ int LA99_21 = input.LA(1);
+
+
+ int index99_21 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_21);
+ if ( s>=0 ) return s;
+ break;
+ case 21 :
+ int LA99_22 = input.LA(1);
+
+
+ int index99_22 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_22);
+ if ( s>=0 ) return s;
+ break;
+ case 22 :
+ int LA99_23 = input.LA(1);
+
+
+ int index99_23 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_23);
+ if ( s>=0 ) return s;
+ break;
+ case 23 :
+ int LA99_24 = input.LA(1);
+
+
+ int index99_24 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_24);
+ if ( s>=0 ) return s;
+ break;
+ case 24 :
+ int LA99_25 = input.LA(1);
+
+
+ int index99_25 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_25);
+ if ( s>=0 ) return s;
+ break;
+ case 25 :
+ int LA99_26 = input.LA(1);
+
+
+ int index99_26 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_26);
+ if ( s>=0 ) return s;
+ break;
+ case 26 :
+ int LA99_27 = input.LA(1);
+
+
+ int index99_27 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_27);
+ if ( s>=0 ) return s;
+ break;
+ case 27 :
+ int LA99_28 = input.LA(1);
+
+
+ int index99_28 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_28);
+ if ( s>=0 ) return s;
+ break;
+ case 28 :
+ int LA99_29 = input.LA(1);
+
+
+ int index99_29 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_29);
+ if ( s>=0 ) return s;
+ break;
+ case 29 :
+ int LA99_30 = input.LA(1);
+
+
+ int index99_30 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_30);
+ if ( s>=0 ) return s;
+ break;
+ case 30 :
+ int LA99_31 = input.LA(1);
+
+
+ int index99_31 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_31);
+ if ( s>=0 ) return s;
+ break;
+ case 31 :
+ int LA99_32 = input.LA(1);
+
+
+ int index99_32 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+ else if ( (true) ) {s = 33;}
+
+
+ input.seek(index99_32);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 99, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String dfa_78s = "\117\uffff";
+ static final String dfa_79s = "\1\2\116\uffff";
+ static final String dfa_80s = "\1\4\1\0\115\uffff";
+ static final String dfa_81s = "\1\130\1\0\115\uffff";
+ static final String dfa_82s = "\2\uffff\1\2\113\uffff\1\1";
+ static final String dfa_83s = "\1\uffff\1\0\115\uffff}>";
+ static final String[] dfa_84s = {
+ "\5\2\4\uffff\4\2\1\uffff\1\2\1\uffff\3\2\1\uffff\10\2\1\1\35\2\1\uffff\30\2\1\uffff\1\2",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] dfa_78 = DFA.unpackEncodedString(dfa_78s);
+ static final short[] dfa_79 = DFA.unpackEncodedString(dfa_79s);
+ static final char[] dfa_80 = DFA.unpackEncodedStringToUnsignedChars(dfa_80s);
+ static final char[] dfa_81 = DFA.unpackEncodedStringToUnsignedChars(dfa_81s);
+ static final short[] dfa_82 = DFA.unpackEncodedString(dfa_82s);
+ static final short[] dfa_83 = DFA.unpackEncodedString(dfa_83s);
+ static final short[][] dfa_84 = unpackEncodedStringArray(dfa_84s);
+
+ class DFA117 extends DFA {
+
+ public DFA117(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 117;
+ this.eot = dfa_78;
+ this.eof = dfa_79;
+ this.min = dfa_80;
+ this.max = dfa_81;
+ this.accept = dfa_82;
+ this.special = dfa_83;
+ this.transition = dfa_84;
+ }
+ public String getDescription() {
+ return "6318:3: ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA117_1 = input.LA(1);
+
+
+ int index117_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred50_InternalOXtype()) ) {s = 78;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index117_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 117, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+ class DFA115 extends DFA {
+
+ public DFA115(BaseRecognizer recognizer) {
+ this.recognizer = recognizer;
+ this.decisionNumber = 115;
+ this.eot = dfa_78;
+ this.eof = dfa_79;
+ this.min = dfa_80;
+ this.max = dfa_81;
+ this.accept = dfa_82;
+ this.special = dfa_83;
+ this.transition = dfa_84;
+ }
+ public String getDescription() {
+ return "6412:5: ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA115_1 = input.LA(1);
+
+
+ int index115_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred52_InternalOXtype()) ) {s = 78;}
+
+ else if ( (true) ) {s = 2;}
+
+
+ input.seek(index115_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 115, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+
+ public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000024100L});
+ public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000008100L});
+ public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000010100L});
+ public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000040002L});
+ public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000000100L});
+ public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000100002L});
+ public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x902300010358E1F0L,0x00000000002FFCE2L});
+ public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000600000L});
+ public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000400000L});
+ public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000800000L});
+ public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x902300010318E1F0L,0x00000000002FFCE2L});
+ public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000002000000L});
+ public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x902300010718E1F0L,0x00000000002FFCE2L});
+ public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000004200000L});
+ public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000200002L});
+ public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x00000003F8000002L});
+ public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000100000000L});
+ public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000600000000L});
+ public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000800000002L});
+ public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000001000000002L});
+ public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x000001E000000002L});
+ public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000020700000002L});
+ public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000200000100100L});
+ public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000FC0300000002L});
+ public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000100000000000L});
+ public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000200000000L});
+ public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000200100000000L});
+ public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0003000000000002L});
+ public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x001C000000010002L});
+ public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0040000000000002L});
+ public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0180000000000002L});
+ public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0E00000000000002L});
+ public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x000000000000E100L,0x0000000000000400L});
+ public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x000000010000E100L,0x0000000000000C00L});
+ public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000200000100100L,0x0000000000800000L});
+ public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000200200000L});
+ public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0E00000002100002L});
+ public static final BitSet FOLLOW_41 = new BitSet(new long[]{0xD02320010358E1F0L,0x00000000002FFCE2L});
+ public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0E00000002000002L});
+ public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x1000000000000000L});
+ public static final BitSet FOLLOW_44 = new BitSet(new long[]{0xB02300010318E1F0L,0x00000000002FFCE2L});
+ public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x2000000000200000L});
+ public static final BitSet FOLLOW_46 = new BitSet(new long[]{0xD02320010718E1F0L,0x00000000002FFFE2L});
+ public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x4000000000200000L});
+ public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x902300010718E1F0L,0x00000000002FFFE2L});
+ public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000004000000L});
+ public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x90230001031CE1F2L,0x00000000002FFFE2L});
+ public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x902300010318E1F2L,0x00000000002FFFE2L});
+ public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000100000L});
+ public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000001L});
+ public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x902320010318E1F0L,0x00000000002FFCE2L});
+ public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
+ public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x2000200000300100L,0x000000000000001CL});
+ public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x2000000000000000L});
+ public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000000200000L,0x0000000000000014L});
+ public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000000200000L,0x0000000000000004L});
+ public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x90230001031CE1F0L,0x00000000002FFFE2L});
+ public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000240000L});
+ public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x902300010318E1F0L,0x00000000002FFFE2L});
+ public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x90230001031CE1F0L,0x00000000002FFCE2L});
+ public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000000040000L});
+ public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
+ public static final BitSet FOLLOW_66 = new BitSet(new long[]{0xB02300010318E1F0L,0x00000000002FFFE2L});
+ public static final BitSet FOLLOW_67 = new BitSet(new long[]{0xB0230001031CE1F0L,0x00000000002FFFE2L});
+ public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0000000000800002L});
+ public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000000002100002L});
+ public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000000002000002L});
+ public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000000102100002L});
+ public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000000002400000L});
+ public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x902300010318E1F2L,0x00000000002FFCE2L});
+ public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0000000000000000L,0x0000000000500000L});
+ public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0000000000000002L,0x0000000000500000L});
+ public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0200000000000002L});
+ public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x00000000000000C0L});
+ public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0000200000500100L});
+ public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0000200000000000L});
+ public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x0000000100000002L});
+ public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0200000100000002L});
+ public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000C00L});
+ public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000000000000002L,0x0000000001000000L});
+ public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0200000000000000L});
+ public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000000000010000L});
+ public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0000000000000102L});
+
+}
\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/scoping/AbstractOXtypeScopeProvider.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/scoping/AbstractOXtypeScopeProvider.java
new file mode 100644
index 0000000..7015760
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/scoping/AbstractOXtypeScopeProvider.java
@@ -0,0 +1,9 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.scoping;
+
+import org.eclipse.xtext.xbase.annotations.typesystem.XbaseWithAnnotationsBatchScopeProvider;
+
+public abstract class AbstractOXtypeScopeProvider extends XbaseWithAnnotationsBatchScopeProvider {
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/serializer/OXtypeSemanticSequencer.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/serializer/OXtypeSemanticSequencer.java
new file mode 100644
index 0000000..267bfd5
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/serializer/OXtypeSemanticSequencer.java
@@ -0,0 +1,402 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.serializer;
+
+import com.google.inject.Inject;
+import java.util.Set;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration;
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+import org.eclipse.xtext.Action;
+import org.eclipse.xtext.Parameter;
+import org.eclipse.xtext.ParserRule;
+import org.eclipse.xtext.common.types.JvmFormalParameter;
+import org.eclipse.xtext.common.types.JvmGenericArrayTypeReference;
+import org.eclipse.xtext.common.types.JvmInnerTypeReference;
+import org.eclipse.xtext.common.types.JvmLowerBound;
+import org.eclipse.xtext.common.types.JvmParameterizedTypeReference;
+import org.eclipse.xtext.common.types.JvmTypeParameter;
+import org.eclipse.xtext.common.types.JvmUpperBound;
+import org.eclipse.xtext.common.types.JvmWildcardTypeReference;
+import org.eclipse.xtext.common.types.TypesPackage;
+import org.eclipse.xtext.serializer.ISerializationContext;
+import org.eclipse.xtext.xbase.XAssignment;
+import org.eclipse.xtext.xbase.XBasicForLoopExpression;
+import org.eclipse.xtext.xbase.XBinaryOperation;
+import org.eclipse.xtext.xbase.XBlockExpression;
+import org.eclipse.xtext.xbase.XBooleanLiteral;
+import org.eclipse.xtext.xbase.XCasePart;
+import org.eclipse.xtext.xbase.XCastedExpression;
+import org.eclipse.xtext.xbase.XCatchClause;
+import org.eclipse.xtext.xbase.XClosure;
+import org.eclipse.xtext.xbase.XConstructorCall;
+import org.eclipse.xtext.xbase.XDoWhileExpression;
+import org.eclipse.xtext.xbase.XFeatureCall;
+import org.eclipse.xtext.xbase.XForLoopExpression;
+import org.eclipse.xtext.xbase.XIfExpression;
+import org.eclipse.xtext.xbase.XInstanceOfExpression;
+import org.eclipse.xtext.xbase.XListLiteral;
+import org.eclipse.xtext.xbase.XMemberFeatureCall;
+import org.eclipse.xtext.xbase.XNullLiteral;
+import org.eclipse.xtext.xbase.XNumberLiteral;
+import org.eclipse.xtext.xbase.XPostfixOperation;
+import org.eclipse.xtext.xbase.XReturnExpression;
+import org.eclipse.xtext.xbase.XSetLiteral;
+import org.eclipse.xtext.xbase.XStringLiteral;
+import org.eclipse.xtext.xbase.XSwitchExpression;
+import org.eclipse.xtext.xbase.XSynchronizedExpression;
+import org.eclipse.xtext.xbase.XThrowExpression;
+import org.eclipse.xtext.xbase.XTryCatchFinallyExpression;
+import org.eclipse.xtext.xbase.XTypeLiteral;
+import org.eclipse.xtext.xbase.XUnaryOperation;
+import org.eclipse.xtext.xbase.XVariableDeclaration;
+import org.eclipse.xtext.xbase.XWhileExpression;
+import org.eclipse.xtext.xbase.XbasePackage;
+import org.eclipse.xtext.xbase.annotations.serializer.XbaseWithAnnotationsSemanticSequencer;
+import org.eclipse.xtext.xbase.annotations.xAnnotations.XAnnotation;
+import org.eclipse.xtext.xbase.annotations.xAnnotations.XAnnotationElementValuePair;
+import org.eclipse.xtext.xbase.annotations.xAnnotations.XAnnotationsPackage;
+import org.eclipse.xtext.xtype.XFunctionTypeRef;
+import org.eclipse.xtext.xtype.XImportSection;
+import org.eclipse.xtext.xtype.XtypePackage;
+
+@SuppressWarnings("all")
+public class OXtypeSemanticSequencer extends XbaseWithAnnotationsSemanticSequencer {
+
+ @Inject
+ private OXtypeGrammarAccess grammarAccess;
+
+ @Override
+ public void sequence(ISerializationContext context, EObject semanticObject) {
+ EPackage epackage = semanticObject.eClass().getEPackage();
+ ParserRule rule = context.getParserRule();
+ Action action = context.getAssignedAction();
+ Set<Parameter> parameters = context.getEnabledBooleanParameters();
+ if (epackage == OXtypePackage.eINSTANCE)
+ switch (semanticObject.eClass().getClassifierID()) {
+ case OXtypePackage.OX_IMPORT_DECLARATION:
+ sequence_XImportDeclaration(context, (OXImportDeclaration) semanticObject);
+ return;
+ }
+ else if (epackage == TypesPackage.eINSTANCE)
+ switch (semanticObject.eClass().getClassifierID()) {
+ case TypesPackage.JVM_FORMAL_PARAMETER:
+ if (rule == grammarAccess.getFullJvmFormalParameterRule()) {
+ sequence_FullJvmFormalParameter(context, (JvmFormalParameter) semanticObject);
+ return;
+ }
+ else if (rule == grammarAccess.getJvmFormalParameterRule()) {
+ sequence_JvmFormalParameter(context, (JvmFormalParameter) semanticObject);
+ return;
+ }
+ else break;
+ case TypesPackage.JVM_GENERIC_ARRAY_TYPE_REFERENCE:
+ sequence_JvmTypeReference(context, (JvmGenericArrayTypeReference) semanticObject);
+ return;
+ case TypesPackage.JVM_INNER_TYPE_REFERENCE:
+ sequence_JvmParameterizedTypeReference(context, (JvmInnerTypeReference) semanticObject);
+ return;
+ case TypesPackage.JVM_LOWER_BOUND:
+ if (rule == grammarAccess.getJvmLowerBoundAndedRule()) {
+ sequence_JvmLowerBoundAnded(context, (JvmLowerBound) semanticObject);
+ return;
+ }
+ else if (rule == grammarAccess.getJvmLowerBoundRule()) {
+ sequence_JvmLowerBound(context, (JvmLowerBound) semanticObject);
+ return;
+ }
+ else break;
+ case TypesPackage.JVM_PARAMETERIZED_TYPE_REFERENCE:
+ if (action == grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()) {
+ sequence_JvmParameterizedTypeReference_JvmInnerTypeReference_1_4_0_0_0(context, (JvmParameterizedTypeReference) semanticObject);
+ return;
+ }
+ else if (rule == grammarAccess.getJvmTypeReferenceRule()
+ || action == grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()
+ || rule == grammarAccess.getJvmParameterizedTypeReferenceRule()
+ || rule == grammarAccess.getJvmArgumentTypeReferenceRule()) {
+ sequence_JvmParameterizedTypeReference(context, (JvmParameterizedTypeReference) semanticObject);
+ return;
+ }
+ else break;
+ case TypesPackage.JVM_TYPE_PARAMETER:
+ sequence_JvmTypeParameter(context, (JvmTypeParameter) semanticObject);
+ return;
+ case TypesPackage.JVM_UPPER_BOUND:
+ if (rule == grammarAccess.getJvmUpperBoundAndedRule()) {
+ sequence_JvmUpperBoundAnded(context, (JvmUpperBound) semanticObject);
+ return;
+ }
+ else if (rule == grammarAccess.getJvmUpperBoundRule()) {
+ sequence_JvmUpperBound(context, (JvmUpperBound) semanticObject);
+ return;
+ }
+ else break;
+ case TypesPackage.JVM_WILDCARD_TYPE_REFERENCE:
+ sequence_JvmWildcardTypeReference(context, (JvmWildcardTypeReference) semanticObject);
+ return;
+ }
+ else if (epackage == XAnnotationsPackage.eINSTANCE)
+ switch (semanticObject.eClass().getClassifierID()) {
+ case XAnnotationsPackage.XANNOTATION:
+ sequence_XAnnotation(context, (XAnnotation) semanticObject);
+ return;
+ case XAnnotationsPackage.XANNOTATION_ELEMENT_VALUE_PAIR:
+ sequence_XAnnotationElementValuePair(context, (XAnnotationElementValuePair) semanticObject);
+ return;
+ }
+ else if (epackage == XbasePackage.eINSTANCE)
+ switch (semanticObject.eClass().getClassifierID()) {
+ case XbasePackage.XASSIGNMENT:
+ sequence_XAssignment_XMemberFeatureCall(context, (XAssignment) semanticObject);
+ return;
+ case XbasePackage.XBASIC_FOR_LOOP_EXPRESSION:
+ sequence_XBasicForLoopExpression(context, (XBasicForLoopExpression) semanticObject);
+ return;
+ case XbasePackage.XBINARY_OPERATION:
+ sequence_XAdditiveExpression_XAndExpression_XAssignment_XEqualityExpression_XMultiplicativeExpression_XOrExpression_XOtherOperatorExpression_XRelationalExpression(context, (XBinaryOperation) semanticObject);
+ return;
+ case XbasePackage.XBLOCK_EXPRESSION:
+ if (rule == grammarAccess.getXAnnotationElementValueOrCommaListRule()
+ || action == grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()
+ || rule == grammarAccess.getXAnnotationElementValueRule()
+ || rule == grammarAccess.getXAnnotationOrExpressionRule()
+ || rule == grammarAccess.getXExpressionRule()
+ || rule == grammarAccess.getXAssignmentRule()
+ || action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
+ || rule == grammarAccess.getXOrExpressionRule()
+ || action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXAndExpressionRule()
+ || action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXEqualityExpressionRule()
+ || action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXRelationalExpressionRule()
+ || action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()
+ || action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
+ || rule == grammarAccess.getXOtherOperatorExpressionRule()
+ || action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXAdditiveExpressionRule()
+ || action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXMultiplicativeExpressionRule()
+ || action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXUnaryOperationRule()
+ || rule == grammarAccess.getXCastedExpressionRule()
+ || action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()
+ || rule == grammarAccess.getXPostfixOperationRule()
+ || action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()
+ || rule == grammarAccess.getXMemberFeatureCallRule()
+ || action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()
+ || action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()
+ || rule == grammarAccess.getXPrimaryExpressionRule()
+ || rule == grammarAccess.getXParenthesizedExpressionRule()
+ || rule == grammarAccess.getXBlockExpressionRule()
+ || rule == grammarAccess.getXExpressionOrVarDeclarationRule()) {
+ sequence_XBlockExpression(context, (XBlockExpression) semanticObject);
+ return;
+ }
+ else if (rule == grammarAccess.getXExpressionInClosureRule()) {
+ sequence_XExpressionInClosure(context, (XBlockExpression) semanticObject);
+ return;
+ }
+ else break;
+ case XbasePackage.XBOOLEAN_LITERAL:
+ sequence_XBooleanLiteral(context, (XBooleanLiteral) semanticObject);
+ return;
+ case XbasePackage.XCASE_PART:
+ sequence_XCasePart(context, (XCasePart) semanticObject);
+ return;
+ case XbasePackage.XCASTED_EXPRESSION:
+ sequence_XCastedExpression(context, (XCastedExpression) semanticObject);
+ return;
+ case XbasePackage.XCATCH_CLAUSE:
+ sequence_XCatchClause(context, (XCatchClause) semanticObject);
+ return;
+ case XbasePackage.XCLOSURE:
+ if (rule == grammarAccess.getXAnnotationElementValueOrCommaListRule()
+ || action == grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()
+ || rule == grammarAccess.getXAnnotationElementValueRule()
+ || rule == grammarAccess.getXAnnotationOrExpressionRule()
+ || rule == grammarAccess.getXExpressionRule()
+ || rule == grammarAccess.getXAssignmentRule()
+ || action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
+ || rule == grammarAccess.getXOrExpressionRule()
+ || action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXAndExpressionRule()
+ || action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXEqualityExpressionRule()
+ || action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXRelationalExpressionRule()
+ || action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()
+ || action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
+ || rule == grammarAccess.getXOtherOperatorExpressionRule()
+ || action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXAdditiveExpressionRule()
+ || action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXMultiplicativeExpressionRule()
+ || action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXUnaryOperationRule()
+ || rule == grammarAccess.getXCastedExpressionRule()
+ || action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()
+ || rule == grammarAccess.getXPostfixOperationRule()
+ || action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()
+ || rule == grammarAccess.getXMemberFeatureCallRule()
+ || action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()
+ || action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()
+ || rule == grammarAccess.getXPrimaryExpressionRule()
+ || rule == grammarAccess.getXLiteralRule()
+ || rule == grammarAccess.getXClosureRule()
+ || rule == grammarAccess.getXParenthesizedExpressionRule()
+ || rule == grammarAccess.getXExpressionOrVarDeclarationRule()) {
+ sequence_XClosure(context, (XClosure) semanticObject);
+ return;
+ }
+ else if (rule == grammarAccess.getXShortClosureRule()) {
+ sequence_XShortClosure(context, (XClosure) semanticObject);
+ return;
+ }
+ else break;
+ case XbasePackage.XCONSTRUCTOR_CALL:
+ sequence_XConstructorCall(context, (XConstructorCall) semanticObject);
+ return;
+ case XbasePackage.XDO_WHILE_EXPRESSION:
+ sequence_XDoWhileExpression(context, (XDoWhileExpression) semanticObject);
+ return;
+ case XbasePackage.XFEATURE_CALL:
+ sequence_XFeatureCall(context, (XFeatureCall) semanticObject);
+ return;
+ case XbasePackage.XFOR_LOOP_EXPRESSION:
+ sequence_XForLoopExpression(context, (XForLoopExpression) semanticObject);
+ return;
+ case XbasePackage.XIF_EXPRESSION:
+ sequence_XIfExpression(context, (XIfExpression) semanticObject);
+ return;
+ case XbasePackage.XINSTANCE_OF_EXPRESSION:
+ sequence_XRelationalExpression(context, (XInstanceOfExpression) semanticObject);
+ return;
+ case XbasePackage.XLIST_LITERAL:
+ if (rule == grammarAccess.getXAnnotationElementValueOrCommaListRule()) {
+ sequence_XAnnotationElementValueOrCommaList_XListLiteral(context, (XListLiteral) semanticObject);
+ return;
+ }
+ else if (rule == grammarAccess.getXAnnotationElementValueRule()) {
+ sequence_XAnnotationElementValue_XListLiteral(context, (XListLiteral) semanticObject);
+ return;
+ }
+ else if (action == grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()
+ || rule == grammarAccess.getXAnnotationOrExpressionRule()
+ || rule == grammarAccess.getXExpressionRule()
+ || rule == grammarAccess.getXAssignmentRule()
+ || action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
+ || rule == grammarAccess.getXOrExpressionRule()
+ || action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXAndExpressionRule()
+ || action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXEqualityExpressionRule()
+ || action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXRelationalExpressionRule()
+ || action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()
+ || action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
+ || rule == grammarAccess.getXOtherOperatorExpressionRule()
+ || action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXAdditiveExpressionRule()
+ || action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXMultiplicativeExpressionRule()
+ || action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+ || rule == grammarAccess.getXUnaryOperationRule()
+ || rule == grammarAccess.getXCastedExpressionRule()
+ || action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()
+ || rule == grammarAccess.getXPostfixOperationRule()
+ || action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()
+ || rule == grammarAccess.getXMemberFeatureCallRule()
+ || action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()
+ || action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()
+ || rule == grammarAccess.getXPrimaryExpressionRule()
+ || rule == grammarAccess.getXLiteralRule()
+ || rule == grammarAccess.getXCollectionLiteralRule()
+ || rule == grammarAccess.getXListLiteralRule()
+ || rule == grammarAccess.getXParenthesizedExpressionRule()
+ || rule == grammarAccess.getXExpressionOrVarDeclarationRule()) {
+ sequence_XListLiteral(context, (XListLiteral) semanticObject);
+ return;
+ }
+ else break;
+ case XbasePackage.XMEMBER_FEATURE_CALL:
+ sequence_XMemberFeatureCall(context, (XMemberFeatureCall) semanticObject);
+ return;
+ case XbasePackage.XNULL_LITERAL:
+ sequence_XNullLiteral(context, (XNullLiteral) semanticObject);
+ return;
+ case XbasePackage.XNUMBER_LITERAL:
+ sequence_XNumberLiteral(context, (XNumberLiteral) semanticObject);
+ return;
+ case XbasePackage.XPOSTFIX_OPERATION:
+ sequence_XPostfixOperation(context, (XPostfixOperation) semanticObject);
+ return;
+ case XbasePackage.XRETURN_EXPRESSION:
+ sequence_XReturnExpression(context, (XReturnExpression) semanticObject);
+ return;
+ case XbasePackage.XSET_LITERAL:
+ sequence_XSetLiteral(context, (XSetLiteral) semanticObject);
+ return;
+ case XbasePackage.XSTRING_LITERAL:
+ sequence_XStringLiteral(context, (XStringLiteral) semanticObject);
+ return;
+ case XbasePackage.XSWITCH_EXPRESSION:
+ sequence_XSwitchExpression(context, (XSwitchExpression) semanticObject);
+ return;
+ case XbasePackage.XSYNCHRONIZED_EXPRESSION:
+ sequence_XSynchronizedExpression(context, (XSynchronizedExpression) semanticObject);
+ return;
+ case XbasePackage.XTHROW_EXPRESSION:
+ sequence_XThrowExpression(context, (XThrowExpression) semanticObject);
+ return;
+ case XbasePackage.XTRY_CATCH_FINALLY_EXPRESSION:
+ sequence_XTryCatchFinallyExpression(context, (XTryCatchFinallyExpression) semanticObject);
+ return;
+ case XbasePackage.XTYPE_LITERAL:
+ sequence_XTypeLiteral(context, (XTypeLiteral) semanticObject);
+ return;
+ case XbasePackage.XUNARY_OPERATION:
+ sequence_XUnaryOperation(context, (XUnaryOperation) semanticObject);
+ return;
+ case XbasePackage.XVARIABLE_DECLARATION:
+ sequence_XVariableDeclaration(context, (XVariableDeclaration) semanticObject);
+ return;
+ case XbasePackage.XWHILE_EXPRESSION:
+ sequence_XWhileExpression(context, (XWhileExpression) semanticObject);
+ return;
+ }
+ else if (epackage == XtypePackage.eINSTANCE)
+ switch (semanticObject.eClass().getClassifierID()) {
+ case XtypePackage.XFUNCTION_TYPE_REF:
+ sequence_XFunctionTypeRef(context, (XFunctionTypeRef) semanticObject);
+ return;
+ case XtypePackage.XIMPORT_SECTION:
+ sequence_XImportSection(context, (XImportSection) semanticObject);
+ return;
+ }
+ if (errorAcceptor != null)
+ errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
+ }
+
+ /**
+ * Contexts:
+ * XImportDeclaration returns OXImportDeclaration
+ *
+ * Constraint:
+ * (
+ * (static?='static' extension?='extension'? importedType=[JvmDeclaredType|QualifiedNameInStaticImport] (wildcard?='*' | memberName=ValidID)) |
+ * importedType=[JvmDeclaredType|QualifiedName] |
+ * importedNamespace=QualifiedNameWithWildcard |
+ * (fqnImport?='ns' importedFullyQualifiedName=QualifiedName)
+ * )
+ */
+ protected void sequence_XImportDeclaration(ISerializationContext context, OXImportDeclaration semanticObject) {
+ genericSequencer.createSequence(context, semanticObject);
+ }
+
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/serializer/OXtypeSyntacticSequencer.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/serializer/OXtypeSyntacticSequencer.java
new file mode 100644
index 0000000..b9ad555
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/serializer/OXtypeSyntacticSequencer.java
@@ -0,0 +1,265 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.serializer;
+
+import com.google.inject.Inject;
+import java.util.List;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+import org.eclipse.xtext.IGrammarAccess;
+import org.eclipse.xtext.RuleCall;
+import org.eclipse.xtext.nodemodel.INode;
+import org.eclipse.xtext.serializer.analysis.GrammarAlias.AbstractElementAlias;
+import org.eclipse.xtext.serializer.analysis.GrammarAlias.GroupAlias;
+import org.eclipse.xtext.serializer.analysis.GrammarAlias.TokenAlias;
+import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynNavigable;
+import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynTransition;
+import org.eclipse.xtext.serializer.sequencer.AbstractSyntacticSequencer;
+
+@SuppressWarnings("all")
+public class OXtypeSyntacticSequencer extends AbstractSyntacticSequencer {
+
+ protected OXtypeGrammarAccess grammarAccess;
+ protected AbstractElementAlias match_XAnnotation___LeftParenthesisKeyword_3_0_RightParenthesisKeyword_3_2__q;
+ protected AbstractElementAlias match_XBlockExpression_SemicolonKeyword_2_1_q;
+ protected AbstractElementAlias match_XExpressionInClosure_SemicolonKeyword_1_1_q;
+ protected AbstractElementAlias match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q;
+ protected AbstractElementAlias match_XImportDeclaration_SemicolonKeyword_3_q;
+ protected AbstractElementAlias match_XParenthesizedExpression_LeftParenthesisKeyword_0_a;
+ protected AbstractElementAlias match_XParenthesizedExpression_LeftParenthesisKeyword_0_p;
+
+ @Inject
+ protected void init(IGrammarAccess access) {
+ grammarAccess = (OXtypeGrammarAccess) access;
+ match_XAnnotation___LeftParenthesisKeyword_3_0_RightParenthesisKeyword_3_2__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getXAnnotationAccess().getLeftParenthesisKeyword_3_0()), new TokenAlias(false, false, grammarAccess.getXAnnotationAccess().getRightParenthesisKeyword_3_2()));
+ match_XBlockExpression_SemicolonKeyword_2_1_q = new TokenAlias(false, true, grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1());
+ match_XExpressionInClosure_SemicolonKeyword_1_1_q = new TokenAlias(false, true, grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1());
+ match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()), new TokenAlias(false, false, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()));
+ match_XImportDeclaration_SemicolonKeyword_3_q = new TokenAlias(false, true, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_3());
+ match_XParenthesizedExpression_LeftParenthesisKeyword_0_a = new TokenAlias(true, true, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0());
+ match_XParenthesizedExpression_LeftParenthesisKeyword_0_p = new TokenAlias(true, false, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0());
+ }
+
+ @Override
+ protected String getUnassignedRuleCallToken(EObject semanticObject, RuleCall ruleCall, INode node) {
+ if (ruleCall.getRule() == grammarAccess.getArrayBracketsRule())
+ return getArrayBracketsToken(semanticObject, ruleCall, node);
+ else if (ruleCall.getRule() == grammarAccess.getOpSingleAssignRule())
+ return getOpSingleAssignToken(semanticObject, ruleCall, node);
+ return "";
+ }
+
+ /**
+ * ArrayBrackets :
+ * '[' ']'
+ * ;
+ */
+ protected String getArrayBracketsToken(EObject semanticObject, RuleCall ruleCall, INode node) {
+ if (node != null)
+ return getTokenText(node);
+ return "[]";
+ }
+
+ /**
+ * OpSingleAssign:
+ * '='
+ * ;
+ */
+ protected String getOpSingleAssignToken(EObject semanticObject, RuleCall ruleCall, INode node) {
+ if (node != null)
+ return getTokenText(node);
+ return "=";
+ }
+
+ @Override
+ protected void emitUnassignedTokens(EObject semanticObject, ISynTransition transition, INode fromNode, INode toNode) {
+ if (transition.getAmbiguousSyntaxes().isEmpty()) return;
+ List<INode> transitionNodes = collectNodes(fromNode, toNode);
+ for (AbstractElementAlias syntax : transition.getAmbiguousSyntaxes()) {
+ List<INode> syntaxNodes = getNodesFor(transitionNodes, syntax);
+ if (match_XAnnotation___LeftParenthesisKeyword_3_0_RightParenthesisKeyword_3_2__q.equals(syntax))
+ emit_XAnnotation___LeftParenthesisKeyword_3_0_RightParenthesisKeyword_3_2__q(semanticObject, getLastNavigableState(), syntaxNodes);
+ else if (match_XBlockExpression_SemicolonKeyword_2_1_q.equals(syntax))
+ emit_XBlockExpression_SemicolonKeyword_2_1_q(semanticObject, getLastNavigableState(), syntaxNodes);
+ else if (match_XExpressionInClosure_SemicolonKeyword_1_1_q.equals(syntax))
+ emit_XExpressionInClosure_SemicolonKeyword_1_1_q(semanticObject, getLastNavigableState(), syntaxNodes);
+ else if (match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q.equals(syntax))
+ emit_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q(semanticObject, getLastNavigableState(), syntaxNodes);
+ else if (match_XImportDeclaration_SemicolonKeyword_3_q.equals(syntax))
+ emit_XImportDeclaration_SemicolonKeyword_3_q(semanticObject, getLastNavigableState(), syntaxNodes);
+ else if (match_XParenthesizedExpression_LeftParenthesisKeyword_0_a.equals(syntax))
+ emit_XParenthesizedExpression_LeftParenthesisKeyword_0_a(semanticObject, getLastNavigableState(), syntaxNodes);
+ else if (match_XParenthesizedExpression_LeftParenthesisKeyword_0_p.equals(syntax))
+ emit_XParenthesizedExpression_LeftParenthesisKeyword_0_p(semanticObject, getLastNavigableState(), syntaxNodes);
+ else acceptNodes(getLastNavigableState(), syntaxNodes);
+ }
+ }
+
+ /**
+ * Ambiguous syntax:
+ * ('(' ')')?
+ *
+ * This ambiguous syntax occurs at:
+ * annotationType=[JvmAnnotationType|QualifiedName] (ambiguity) (rule end)
+ */
+ protected void emit_XAnnotation___LeftParenthesisKeyword_3_0_RightParenthesisKeyword_3_2__q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {
+ acceptNodes(transition, nodes);
+ }
+
+ /**
+ * Ambiguous syntax:
+ * ';'?
+ *
+ * This ambiguous syntax occurs at:
+ * expressions+=XExpressionOrVarDeclaration (ambiguity) '}' ')' (rule end)
+ * expressions+=XExpressionOrVarDeclaration (ambiguity) '}' (rule end)
+ * expressions+=XExpressionOrVarDeclaration (ambiguity) expressions+=XExpressionOrVarDeclaration
+ */
+ protected void emit_XBlockExpression_SemicolonKeyword_2_1_q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {
+ acceptNodes(transition, nodes);
+ }
+
+ /**
+ * Ambiguous syntax:
+ * ';'?
+ *
+ * This ambiguous syntax occurs at:
+ * expressions+=XExpressionOrVarDeclaration (ambiguity) (rule end)
+ * expressions+=XExpressionOrVarDeclaration (ambiguity) expressions+=XExpressionOrVarDeclaration
+ */
+ protected void emit_XExpressionInClosure_SemicolonKeyword_1_1_q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {
+ acceptNodes(transition, nodes);
+ }
+
+ /**
+ * Ambiguous syntax:
+ * ('(' ')')?
+ *
+ * This ambiguous syntax occurs at:
+ * (rule start) (ambiguity) '=>' returnType=JvmTypeReference
+ */
+ protected void emit_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {
+ acceptNodes(transition, nodes);
+ }
+
+ /**
+ * Ambiguous syntax:
+ * ';'?
+ *
+ * This ambiguous syntax occurs at:
+ * importedFullyQualifiedName=QualifiedName (ambiguity) (rule end)
+ * importedNamespace=QualifiedNameWithWildcard (ambiguity) (rule end)
+ * importedType=[JvmDeclaredType|QualifiedName] (ambiguity) (rule end)
+ * memberName=ValidID (ambiguity) (rule end)
+ * wildcard?='*' (ambiguity) (rule end)
+ */
+ protected void emit_XImportDeclaration_SemicolonKeyword_3_q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {
+ acceptNodes(transition, nodes);
+ }
+
+ /**
+ * Ambiguous syntax:
+ * '('*
+ *
+ * This ambiguous syntax occurs at:
+ * (rule start) (ambiguity) '#' '[' ']' (rule start)
+ * (rule start) (ambiguity) '#' '[' elements+=XExpression
+ * (rule start) (ambiguity) '#' '{' '}' (rule start)
+ * (rule start) (ambiguity) '#' '{' elements+=XExpression
+ * (rule start) (ambiguity) '<' typeArguments+=JvmArgumentTypeReference
+ * (rule start) (ambiguity) '[' declaredFormalParameters+=JvmFormalParameter
+ * (rule start) (ambiguity) '[' explicitSyntax?='|'
+ * (rule start) (ambiguity) '[' expression=XExpressionInClosure
+ * (rule start) (ambiguity) 'do' body=XExpression
+ * (rule start) (ambiguity) 'false' (rule start)
+ * (rule start) (ambiguity) 'for' '(' ';' ';' ')' eachExpression=XExpression
+ * (rule start) (ambiguity) 'for' '(' ';' ';' updateExpressions+=XExpression
+ * (rule start) (ambiguity) 'for' '(' ';' expression=XExpression
+ * (rule start) (ambiguity) 'for' '(' declaredParam=JvmFormalParameter
+ * (rule start) (ambiguity) 'for' '(' initExpressions+=XExpressionOrVarDeclaration
+ * (rule start) (ambiguity) 'if' '(' if=XExpression
+ * (rule start) (ambiguity) 'new' constructor=[JvmConstructor|QualifiedName]
+ * (rule start) (ambiguity) 'null' (rule start)
+ * (rule start) (ambiguity) 'return' (rule start)
+ * (rule start) (ambiguity) 'return' expression=XExpression
+ * (rule start) (ambiguity) 'switch' '(' declaredParam=JvmFormalParameter
+ * (rule start) (ambiguity) 'switch' declaredParam=JvmFormalParameter
+ * (rule start) (ambiguity) 'switch' switch=XExpression
+ * (rule start) (ambiguity) 'synchronized' '(' param=XExpression
+ * (rule start) (ambiguity) 'throw' expression=XExpression
+ * (rule start) (ambiguity) 'try' expression=XExpression
+ * (rule start) (ambiguity) 'typeof' '(' type=[JvmType|QualifiedName]
+ * (rule start) (ambiguity) 'while' '(' predicate=XExpression
+ * (rule start) (ambiguity) '{' '}' (rule start)
+ * (rule start) (ambiguity) '{' expressions+=XExpressionOrVarDeclaration
+ * (rule start) (ambiguity) feature=[JvmIdentifiableElement|FeatureCallID]
+ * (rule start) (ambiguity) feature=[JvmIdentifiableElement|IdOrSuper]
+ * (rule start) (ambiguity) feature=[JvmIdentifiableElement|OpUnary]
+ * (rule start) (ambiguity) isTrue?='true'
+ * (rule start) (ambiguity) value=Number
+ * (rule start) (ambiguity) value=STRING
+ * (rule start) (ambiguity) {XAssignment.assignable=}
+ * (rule start) (ambiguity) {XBinaryOperation.leftOperand=}
+ * (rule start) (ambiguity) {XCastedExpression.target=}
+ * (rule start) (ambiguity) {XInstanceOfExpression.expression=}
+ * (rule start) (ambiguity) {XMemberFeatureCall.memberCallTarget=}
+ * (rule start) (ambiguity) {XPostfixOperation.operand=}
+ */
+ protected void emit_XParenthesizedExpression_LeftParenthesisKeyword_0_a(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {
+ acceptNodes(transition, nodes);
+ }
+
+ /**
+ * Ambiguous syntax:
+ * '('+
+ *
+ * This ambiguous syntax occurs at:
+ * (rule start) (ambiguity) '#' '[' ']' ')' (rule start)
+ * (rule start) (ambiguity) '#' '[' elements+=XExpression
+ * (rule start) (ambiguity) '#' '{' '}' ')' (rule start)
+ * (rule start) (ambiguity) '#' '{' elements+=XExpression
+ * (rule start) (ambiguity) '<' typeArguments+=JvmArgumentTypeReference
+ * (rule start) (ambiguity) '[' declaredFormalParameters+=JvmFormalParameter
+ * (rule start) (ambiguity) '[' explicitSyntax?='|'
+ * (rule start) (ambiguity) '[' expression=XExpressionInClosure
+ * (rule start) (ambiguity) 'do' body=XExpression
+ * (rule start) (ambiguity) 'false' ')' (rule start)
+ * (rule start) (ambiguity) 'for' '(' ';' ';' ')' eachExpression=XExpression
+ * (rule start) (ambiguity) 'for' '(' ';' ';' updateExpressions+=XExpression
+ * (rule start) (ambiguity) 'for' '(' ';' expression=XExpression
+ * (rule start) (ambiguity) 'for' '(' declaredParam=JvmFormalParameter
+ * (rule start) (ambiguity) 'for' '(' initExpressions+=XExpressionOrVarDeclaration
+ * (rule start) (ambiguity) 'if' '(' if=XExpression
+ * (rule start) (ambiguity) 'new' constructor=[JvmConstructor|QualifiedName]
+ * (rule start) (ambiguity) 'null' ')' (rule start)
+ * (rule start) (ambiguity) 'return' ')' (rule start)
+ * (rule start) (ambiguity) 'return' expression=XExpression
+ * (rule start) (ambiguity) 'switch' '(' declaredParam=JvmFormalParameter
+ * (rule start) (ambiguity) 'switch' declaredParam=JvmFormalParameter
+ * (rule start) (ambiguity) 'switch' switch=XExpression
+ * (rule start) (ambiguity) 'synchronized' '(' param=XExpression
+ * (rule start) (ambiguity) 'throw' expression=XExpression
+ * (rule start) (ambiguity) 'try' expression=XExpression
+ * (rule start) (ambiguity) 'typeof' '(' type=[JvmType|QualifiedName]
+ * (rule start) (ambiguity) 'while' '(' predicate=XExpression
+ * (rule start) (ambiguity) '{' '}' ')' (rule start)
+ * (rule start) (ambiguity) '{' expressions+=XExpressionOrVarDeclaration
+ * (rule start) (ambiguity) feature=[JvmIdentifiableElement|FeatureCallID]
+ * (rule start) (ambiguity) feature=[JvmIdentifiableElement|IdOrSuper]
+ * (rule start) (ambiguity) feature=[JvmIdentifiableElement|OpUnary]
+ * (rule start) (ambiguity) isTrue?='true'
+ * (rule start) (ambiguity) value=Number
+ * (rule start) (ambiguity) value=STRING
+ * (rule start) (ambiguity) {XAssignment.assignable=}
+ * (rule start) (ambiguity) {XBinaryOperation.leftOperand=}
+ * (rule start) (ambiguity) {XCastedExpression.target=}
+ * (rule start) (ambiguity) {XInstanceOfExpression.expression=}
+ * (rule start) (ambiguity) {XMemberFeatureCall.memberCallTarget=}
+ * (rule start) (ambiguity) {XPostfixOperation.operand=}
+ */
+ protected void emit_XParenthesizedExpression_LeftParenthesisKeyword_0_p(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {
+ acceptNodes(transition, nodes);
+ }
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/services/OXtypeGrammarAccess.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/services/OXtypeGrammarAccess.java
new file mode 100644
index 0000000..e3057d1
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/services/OXtypeGrammarAccess.java
@@ -0,0 +1,1184 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.services;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.List;
+import org.eclipse.xtext.Action;
+import org.eclipse.xtext.Alternatives;
+import org.eclipse.xtext.Assignment;
+import org.eclipse.xtext.CrossReference;
+import org.eclipse.xtext.Grammar;
+import org.eclipse.xtext.GrammarUtil;
+import org.eclipse.xtext.Group;
+import org.eclipse.xtext.Keyword;
+import org.eclipse.xtext.ParserRule;
+import org.eclipse.xtext.RuleCall;
+import org.eclipse.xtext.TerminalRule;
+import org.eclipse.xtext.service.AbstractElementFinder.AbstractGrammarElementFinder;
+import org.eclipse.xtext.service.GrammarProvider;
+import org.eclipse.xtext.xbase.annotations.services.XbaseWithAnnotationsGrammarAccess;
+import org.eclipse.xtext.xbase.services.XbaseGrammarAccess;
+import org.eclipse.xtext.xbase.services.XtypeGrammarAccess;
+
+@Singleton
+public class OXtypeGrammarAccess extends AbstractGrammarElementFinder {
+
+ public class XImportDeclarationElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.osbp.xtext.oxtype.OXtype.XImportDeclaration");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cOXImportDeclarationAction_0 = (Action)cGroup.eContents().get(0);
+ private final Keyword cImportKeyword_1 = (Keyword)cGroup.eContents().get(1);
+ private final Alternatives cAlternatives_2 = (Alternatives)cGroup.eContents().get(2);
+ private final Group cGroup_2_0 = (Group)cAlternatives_2.eContents().get(0);
+ private final Assignment cStaticAssignment_2_0_0 = (Assignment)cGroup_2_0.eContents().get(0);
+ private final Keyword cStaticStaticKeyword_2_0_0_0 = (Keyword)cStaticAssignment_2_0_0.eContents().get(0);
+ private final Assignment cExtensionAssignment_2_0_1 = (Assignment)cGroup_2_0.eContents().get(1);
+ private final Keyword cExtensionExtensionKeyword_2_0_1_0 = (Keyword)cExtensionAssignment_2_0_1.eContents().get(0);
+ private final Assignment cImportedTypeAssignment_2_0_2 = (Assignment)cGroup_2_0.eContents().get(2);
+ private final CrossReference cImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0 = (CrossReference)cImportedTypeAssignment_2_0_2.eContents().get(0);
+ private final RuleCall cImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_2_0_2_0_1 = (RuleCall)cImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0.eContents().get(1);
+ private final Alternatives cAlternatives_2_0_3 = (Alternatives)cGroup_2_0.eContents().get(3);
+ private final Assignment cWildcardAssignment_2_0_3_0 = (Assignment)cAlternatives_2_0_3.eContents().get(0);
+ private final Keyword cWildcardAsteriskKeyword_2_0_3_0_0 = (Keyword)cWildcardAssignment_2_0_3_0.eContents().get(0);
+ private final Assignment cMemberNameAssignment_2_0_3_1 = (Assignment)cAlternatives_2_0_3.eContents().get(1);
+ private final RuleCall cMemberNameValidIDParserRuleCall_2_0_3_1_0 = (RuleCall)cMemberNameAssignment_2_0_3_1.eContents().get(0);
+ private final Assignment cImportedTypeAssignment_2_1 = (Assignment)cAlternatives_2.eContents().get(1);
+ private final CrossReference cImportedTypeJvmDeclaredTypeCrossReference_2_1_0 = (CrossReference)cImportedTypeAssignment_2_1.eContents().get(0);
+ private final RuleCall cImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_2_1_0_1 = (RuleCall)cImportedTypeJvmDeclaredTypeCrossReference_2_1_0.eContents().get(1);
+ private final Assignment cImportedNamespaceAssignment_2_2 = (Assignment)cAlternatives_2.eContents().get(2);
+ private final RuleCall cImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0 = (RuleCall)cImportedNamespaceAssignment_2_2.eContents().get(0);
+ private final Group cGroup_2_3 = (Group)cAlternatives_2.eContents().get(3);
+ private final Assignment cFqnImportAssignment_2_3_0 = (Assignment)cGroup_2_3.eContents().get(0);
+ private final Keyword cFqnImportNsKeyword_2_3_0_0 = (Keyword)cFqnImportAssignment_2_3_0.eContents().get(0);
+ private final Assignment cImportedFullyQualifiedNameAssignment_2_3_1 = (Assignment)cGroup_2_3.eContents().get(1);
+ private final RuleCall cImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0 = (RuleCall)cImportedFullyQualifiedNameAssignment_2_3_1.eContents().get(0);
+ private final Keyword cSemicolonKeyword_3 = (Keyword)cGroup.eContents().get(3);
+
+ //@ Override XImportDeclaration OXImportDeclaration:
+ // {OXImportDeclaration}
+ // 'import' (static?='static' extension?='extension'? importedType=[JvmDeclaredType|QualifiedNameInStaticImport]
+ // (wildcard?='*' | memberName=ValidID) | importedType=[JvmDeclaredType|QualifiedName] |
+ // importedNamespace=QualifiedNameWithWildcard
+ // | fqnImport?='ns' importedFullyQualifiedName=QualifiedName) ';'?;
+ @Override public ParserRule getRule() { return rule; }
+
+ //{OXImportDeclaration} 'import' (static?='static' extension?='extension'?
+ //importedType=[JvmDeclaredType|QualifiedNameInStaticImport] (wildcard?='*' | memberName=ValidID) |
+ //importedType=[JvmDeclaredType|QualifiedName] | importedNamespace=QualifiedNameWithWildcard | fqnImport?='ns'
+ //importedFullyQualifiedName=QualifiedName) ';'?
+ public Group getGroup() { return cGroup; }
+
+ //{OXImportDeclaration}
+ public Action getOXImportDeclarationAction_0() { return cOXImportDeclarationAction_0; }
+
+ //'import'
+ public Keyword getImportKeyword_1() { return cImportKeyword_1; }
+
+ //static?='static' extension?='extension'? importedType=[JvmDeclaredType|QualifiedNameInStaticImport] (wildcard?='*' |
+ //memberName=ValidID) | importedType=[JvmDeclaredType|QualifiedName] | importedNamespace=QualifiedNameWithWildcard |
+ //fqnImport?='ns' importedFullyQualifiedName=QualifiedName
+ public Alternatives getAlternatives_2() { return cAlternatives_2; }
+
+ //static?='static' extension?='extension'? importedType=[JvmDeclaredType|QualifiedNameInStaticImport] (wildcard?='*' |
+ //memberName=ValidID)
+ public Group getGroup_2_0() { return cGroup_2_0; }
+
+ //static?='static'
+ public Assignment getStaticAssignment_2_0_0() { return cStaticAssignment_2_0_0; }
+
+ //'static'
+ public Keyword getStaticStaticKeyword_2_0_0_0() { return cStaticStaticKeyword_2_0_0_0; }
+
+ //extension?='extension'?
+ public Assignment getExtensionAssignment_2_0_1() { return cExtensionAssignment_2_0_1; }
+
+ //'extension'
+ public Keyword getExtensionExtensionKeyword_2_0_1_0() { return cExtensionExtensionKeyword_2_0_1_0; }
+
+ //importedType=[JvmDeclaredType|QualifiedNameInStaticImport]
+ public Assignment getImportedTypeAssignment_2_0_2() { return cImportedTypeAssignment_2_0_2; }
+
+ //[JvmDeclaredType|QualifiedNameInStaticImport]
+ public CrossReference getImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0() { return cImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0; }
+
+ //QualifiedNameInStaticImport
+ public RuleCall getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_2_0_2_0_1() { return cImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_2_0_2_0_1; }
+
+ //wildcard?='*' | memberName=ValidID
+ public Alternatives getAlternatives_2_0_3() { return cAlternatives_2_0_3; }
+
+ //wildcard?='*'
+ public Assignment getWildcardAssignment_2_0_3_0() { return cWildcardAssignment_2_0_3_0; }
+
+ //'*'
+ public Keyword getWildcardAsteriskKeyword_2_0_3_0_0() { return cWildcardAsteriskKeyword_2_0_3_0_0; }
+
+ //memberName=ValidID
+ public Assignment getMemberNameAssignment_2_0_3_1() { return cMemberNameAssignment_2_0_3_1; }
+
+ //ValidID
+ public RuleCall getMemberNameValidIDParserRuleCall_2_0_3_1_0() { return cMemberNameValidIDParserRuleCall_2_0_3_1_0; }
+
+ //importedType=[JvmDeclaredType|QualifiedName]
+ public Assignment getImportedTypeAssignment_2_1() { return cImportedTypeAssignment_2_1; }
+
+ //[JvmDeclaredType|QualifiedName]
+ public CrossReference getImportedTypeJvmDeclaredTypeCrossReference_2_1_0() { return cImportedTypeJvmDeclaredTypeCrossReference_2_1_0; }
+
+ //QualifiedName
+ public RuleCall getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_2_1_0_1() { return cImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_2_1_0_1; }
+
+ //importedNamespace=QualifiedNameWithWildcard
+ public Assignment getImportedNamespaceAssignment_2_2() { return cImportedNamespaceAssignment_2_2; }
+
+ //QualifiedNameWithWildcard
+ public RuleCall getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0() { return cImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0; }
+
+ //fqnImport?='ns' importedFullyQualifiedName=QualifiedName
+ public Group getGroup_2_3() { return cGroup_2_3; }
+
+ //fqnImport?='ns'
+ public Assignment getFqnImportAssignment_2_3_0() { return cFqnImportAssignment_2_3_0; }
+
+ //'ns'
+ public Keyword getFqnImportNsKeyword_2_3_0_0() { return cFqnImportNsKeyword_2_3_0_0; }
+
+ //importedFullyQualifiedName=QualifiedName
+ public Assignment getImportedFullyQualifiedNameAssignment_2_3_1() { return cImportedFullyQualifiedNameAssignment_2_3_1; }
+
+ //QualifiedName
+ public RuleCall getImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0() { return cImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0; }
+
+ //';'?
+ public Keyword getSemicolonKeyword_3() { return cSemicolonKeyword_3; }
+ }
+
+
+ private final XImportDeclarationElements pXImportDeclaration;
+
+ private final Grammar grammar;
+
+ private final XbaseWithAnnotationsGrammarAccess gaXbaseWithAnnotations;
+
+ private final XbaseGrammarAccess gaXbase;
+
+ private final XtypeGrammarAccess gaXtype;
+
+ @Inject
+ public OXtypeGrammarAccess(GrammarProvider grammarProvider,
+ XbaseWithAnnotationsGrammarAccess gaXbaseWithAnnotations,
+ XbaseGrammarAccess gaXbase,
+ XtypeGrammarAccess gaXtype) {
+ this.grammar = internalFindGrammar(grammarProvider);
+ this.gaXbaseWithAnnotations = gaXbaseWithAnnotations;
+ this.gaXbase = gaXbase;
+ this.gaXtype = gaXtype;
+ this.pXImportDeclaration = new XImportDeclarationElements();
+ }
+
+ protected Grammar internalFindGrammar(GrammarProvider grammarProvider) {
+ Grammar grammar = grammarProvider.getGrammar(this);
+ while (grammar != null) {
+ if ("org.eclipse.osbp.xtext.oxtype.OXtype".equals(grammar.getName())) {
+ return grammar;
+ }
+ List<Grammar> grammars = grammar.getUsedGrammars();
+ if (!grammars.isEmpty()) {
+ grammar = grammars.iterator().next();
+ } else {
+ return null;
+ }
+ }
+ return grammar;
+ }
+
+ @Override
+ public Grammar getGrammar() {
+ return grammar;
+ }
+
+
+ public XbaseWithAnnotationsGrammarAccess getXbaseWithAnnotationsGrammarAccess() {
+ return gaXbaseWithAnnotations;
+ }
+
+ public XbaseGrammarAccess getXbaseGrammarAccess() {
+ return gaXbase;
+ }
+
+ public XtypeGrammarAccess getXtypeGrammarAccess() {
+ return gaXtype;
+ }
+
+
+ //@ Override XImportDeclaration OXImportDeclaration:
+ // {OXImportDeclaration}
+ // 'import' (static?='static' extension?='extension'? importedType=[JvmDeclaredType|QualifiedNameInStaticImport]
+ // (wildcard?='*' | memberName=ValidID) | importedType=[JvmDeclaredType|QualifiedName] |
+ // importedNamespace=QualifiedNameWithWildcard
+ // | fqnImport?='ns' importedFullyQualifiedName=QualifiedName) ';'?;
+ public XImportDeclarationElements getXImportDeclarationAccess() {
+ return pXImportDeclaration;
+ }
+
+ public ParserRule getXImportDeclarationRule() {
+ return getXImportDeclarationAccess().getRule();
+ }
+
+ //XAnnotation:
+ // {XAnnotation}
+ // '@' annotationType=[types::JvmAnnotationType|QualifiedName] (=> '(' (elementValuePairs+=XAnnotationElementValuePair
+ // (',' elementValuePairs+=XAnnotationElementValuePair)*
+ // | value=XAnnotationElementValueOrCommaList)?
+ // ')')?;
+ public XbaseWithAnnotationsGrammarAccess.XAnnotationElements getXAnnotationAccess() {
+ return gaXbaseWithAnnotations.getXAnnotationAccess();
+ }
+
+ public ParserRule getXAnnotationRule() {
+ return getXAnnotationAccess().getRule();
+ }
+
+ //XAnnotationElementValuePair:
+ // => (element=[types::JvmOperation|ValidID] '=') value=XAnnotationElementValue;
+ public XbaseWithAnnotationsGrammarAccess.XAnnotationElementValuePairElements getXAnnotationElementValuePairAccess() {
+ return gaXbaseWithAnnotations.getXAnnotationElementValuePairAccess();
+ }
+
+ public ParserRule getXAnnotationElementValuePairRule() {
+ return getXAnnotationElementValuePairAccess().getRule();
+ }
+
+ //XAnnotationElementValueOrCommaList xbase::XExpression:
+ // => ({xbase::XListLiteral} '#' '[') (elements+=XAnnotationOrExpression (',' elements+=XAnnotationOrExpression)*)? ']'
+ // | XAnnotationOrExpression ({xbase::XListLiteral.elements+=current} (',' elements+=XAnnotationOrExpression)+)?;
+ public XbaseWithAnnotationsGrammarAccess.XAnnotationElementValueOrCommaListElements getXAnnotationElementValueOrCommaListAccess() {
+ return gaXbaseWithAnnotations.getXAnnotationElementValueOrCommaListAccess();
+ }
+
+ public ParserRule getXAnnotationElementValueOrCommaListRule() {
+ return getXAnnotationElementValueOrCommaListAccess().getRule();
+ }
+
+ //XAnnotationElementValue xbase::XExpression:
+ // => ({xbase::XListLiteral} '#' '[') (elements+=XAnnotationOrExpression (',' elements+=XAnnotationOrExpression)*)? ']'
+ // | XAnnotationOrExpression;
+ public XbaseWithAnnotationsGrammarAccess.XAnnotationElementValueElements getXAnnotationElementValueAccess() {
+ return gaXbaseWithAnnotations.getXAnnotationElementValueAccess();
+ }
+
+ public ParserRule getXAnnotationElementValueRule() {
+ return getXAnnotationElementValueAccess().getRule();
+ }
+
+ //XAnnotationOrExpression xbase::XExpression:
+ // XAnnotation | XExpression;
+ public XbaseWithAnnotationsGrammarAccess.XAnnotationOrExpressionElements getXAnnotationOrExpressionAccess() {
+ return gaXbaseWithAnnotations.getXAnnotationOrExpressionAccess();
+ }
+
+ public ParserRule getXAnnotationOrExpressionRule() {
+ return getXAnnotationOrExpressionAccess().getRule();
+ }
+
+ //XExpression:
+ // XAssignment;
+ public XbaseGrammarAccess.XExpressionElements getXExpressionAccess() {
+ return gaXbase.getXExpressionAccess();
+ }
+
+ public ParserRule getXExpressionRule() {
+ return getXExpressionAccess().getRule();
+ }
+
+ //XAssignment XExpression:
+ // {XAssignment} feature=[types::JvmIdentifiableElement|FeatureCallID] OpSingleAssign value=XAssignment | XOrExpression
+ // (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpMultiAssign])
+ // rightOperand=XAssignment)?;
+ public XbaseGrammarAccess.XAssignmentElements getXAssignmentAccess() {
+ return gaXbase.getXAssignmentAccess();
+ }
+
+ public ParserRule getXAssignmentRule() {
+ return getXAssignmentAccess().getRule();
+ }
+
+ //OpSingleAssign:
+ // '=';
+ public XbaseGrammarAccess.OpSingleAssignElements getOpSingleAssignAccess() {
+ return gaXbase.getOpSingleAssignAccess();
+ }
+
+ public ParserRule getOpSingleAssignRule() {
+ return getOpSingleAssignAccess().getRule();
+ }
+
+ //OpMultiAssign:
+ // '+=' | '-=' | '*=' | '/=' | '%=' |
+ // '<' '<' '=' |
+ // '>' '>'? '>=';
+ public XbaseGrammarAccess.OpMultiAssignElements getOpMultiAssignAccess() {
+ return gaXbase.getOpMultiAssignAccess();
+ }
+
+ public ParserRule getOpMultiAssignRule() {
+ return getOpMultiAssignAccess().getRule();
+ }
+
+ //XOrExpression XExpression:
+ // XAndExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpOr])
+ // rightOperand=XAndExpression)*;
+ public XbaseGrammarAccess.XOrExpressionElements getXOrExpressionAccess() {
+ return gaXbase.getXOrExpressionAccess();
+ }
+
+ public ParserRule getXOrExpressionRule() {
+ return getXOrExpressionAccess().getRule();
+ }
+
+ //OpOr:
+ // '||';
+ public XbaseGrammarAccess.OpOrElements getOpOrAccess() {
+ return gaXbase.getOpOrAccess();
+ }
+
+ public ParserRule getOpOrRule() {
+ return getOpOrAccess().getRule();
+ }
+
+ //XAndExpression XExpression:
+ // XEqualityExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpAnd])
+ // rightOperand=XEqualityExpression)*;
+ public XbaseGrammarAccess.XAndExpressionElements getXAndExpressionAccess() {
+ return gaXbase.getXAndExpressionAccess();
+ }
+
+ public ParserRule getXAndExpressionRule() {
+ return getXAndExpressionAccess().getRule();
+ }
+
+ //OpAnd:
+ // '&&';
+ public XbaseGrammarAccess.OpAndElements getOpAndAccess() {
+ return gaXbase.getOpAndAccess();
+ }
+
+ public ParserRule getOpAndRule() {
+ return getOpAndAccess().getRule();
+ }
+
+ //XEqualityExpression XExpression:
+ // XRelationalExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpEquality])
+ // rightOperand=XRelationalExpression)*;
+ public XbaseGrammarAccess.XEqualityExpressionElements getXEqualityExpressionAccess() {
+ return gaXbase.getXEqualityExpressionAccess();
+ }
+
+ public ParserRule getXEqualityExpressionRule() {
+ return getXEqualityExpressionAccess().getRule();
+ }
+
+ //OpEquality:
+ // '==' | '!=' | '===' | '!==';
+ public XbaseGrammarAccess.OpEqualityElements getOpEqualityAccess() {
+ return gaXbase.getOpEqualityAccess();
+ }
+
+ public ParserRule getOpEqualityRule() {
+ return getOpEqualityAccess().getRule();
+ }
+
+ //XRelationalExpression XExpression:
+ // XOtherOperatorExpression (=> ({XInstanceOfExpression.expression=current} 'instanceof') type=JvmTypeReference |
+ // => ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpCompare])
+ // rightOperand=XOtherOperatorExpression)*;
+ public XbaseGrammarAccess.XRelationalExpressionElements getXRelationalExpressionAccess() {
+ return gaXbase.getXRelationalExpressionAccess();
+ }
+
+ public ParserRule getXRelationalExpressionRule() {
+ return getXRelationalExpressionAccess().getRule();
+ }
+
+ //OpCompare:
+ // '>=' | '<' '=' | '>' | '<';
+ public XbaseGrammarAccess.OpCompareElements getOpCompareAccess() {
+ return gaXbase.getOpCompareAccess();
+ }
+
+ public ParserRule getOpCompareRule() {
+ return getOpCompareAccess().getRule();
+ }
+
+ //XOtherOperatorExpression XExpression:
+ // XAdditiveExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpOther])
+ // rightOperand=XAdditiveExpression)*;
+ public XbaseGrammarAccess.XOtherOperatorExpressionElements getXOtherOperatorExpressionAccess() {
+ return gaXbase.getXOtherOperatorExpressionAccess();
+ }
+
+ public ParserRule getXOtherOperatorExpressionRule() {
+ return getXOtherOperatorExpressionAccess().getRule();
+ }
+
+ //OpOther:
+ // '->'
+ // | '..<'
+ // | '>' '..'
+ // | '..'
+ // | '=>'
+ // | '>' (=> ('>' '>') | '>') | '<' (=> ('<' '<') | '<' | '=>') | '<>'
+ // | '?:';
+ public XbaseGrammarAccess.OpOtherElements getOpOtherAccess() {
+ return gaXbase.getOpOtherAccess();
+ }
+
+ public ParserRule getOpOtherRule() {
+ return getOpOtherAccess().getRule();
+ }
+
+ //XAdditiveExpression XExpression:
+ // XMultiplicativeExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpAdd])
+ // rightOperand=XMultiplicativeExpression)*;
+ public XbaseGrammarAccess.XAdditiveExpressionElements getXAdditiveExpressionAccess() {
+ return gaXbase.getXAdditiveExpressionAccess();
+ }
+
+ public ParserRule getXAdditiveExpressionRule() {
+ return getXAdditiveExpressionAccess().getRule();
+ }
+
+ //OpAdd:
+ // '+' | '-';
+ public XbaseGrammarAccess.OpAddElements getOpAddAccess() {
+ return gaXbase.getOpAddAccess();
+ }
+
+ public ParserRule getOpAddRule() {
+ return getOpAddAccess().getRule();
+ }
+
+ //XMultiplicativeExpression XExpression:
+ // XUnaryOperation (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpMulti])
+ // rightOperand=XUnaryOperation)*;
+ public XbaseGrammarAccess.XMultiplicativeExpressionElements getXMultiplicativeExpressionAccess() {
+ return gaXbase.getXMultiplicativeExpressionAccess();
+ }
+
+ public ParserRule getXMultiplicativeExpressionRule() {
+ return getXMultiplicativeExpressionAccess().getRule();
+ }
+
+ //OpMulti:
+ // '*' | '**' | '/' | '%';
+ public XbaseGrammarAccess.OpMultiElements getOpMultiAccess() {
+ return gaXbase.getOpMultiAccess();
+ }
+
+ public ParserRule getOpMultiRule() {
+ return getOpMultiAccess().getRule();
+ }
+
+ //XUnaryOperation XExpression:
+ // {XUnaryOperation} feature=[types::JvmIdentifiableElement|OpUnary] operand=XUnaryOperation
+ // | XCastedExpression;
+ public XbaseGrammarAccess.XUnaryOperationElements getXUnaryOperationAccess() {
+ return gaXbase.getXUnaryOperationAccess();
+ }
+
+ public ParserRule getXUnaryOperationRule() {
+ return getXUnaryOperationAccess().getRule();
+ }
+
+ //OpUnary:
+ // "!" | "-" | "+";
+ public XbaseGrammarAccess.OpUnaryElements getOpUnaryAccess() {
+ return gaXbase.getOpUnaryAccess();
+ }
+
+ public ParserRule getOpUnaryRule() {
+ return getOpUnaryAccess().getRule();
+ }
+
+ //XCastedExpression XExpression:
+ // XPostfixOperation (=> ({XCastedExpression.target=current} 'as') type=JvmTypeReference)*;
+ public XbaseGrammarAccess.XCastedExpressionElements getXCastedExpressionAccess() {
+ return gaXbase.getXCastedExpressionAccess();
+ }
+
+ public ParserRule getXCastedExpressionRule() {
+ return getXCastedExpressionAccess().getRule();
+ }
+
+ //XPostfixOperation XExpression:
+ // XMemberFeatureCall => ({XPostfixOperation.operand=current} feature=[types::JvmIdentifiableElement|OpPostfix])?;
+ public XbaseGrammarAccess.XPostfixOperationElements getXPostfixOperationAccess() {
+ return gaXbase.getXPostfixOperationAccess();
+ }
+
+ public ParserRule getXPostfixOperationRule() {
+ return getXPostfixOperationAccess().getRule();
+ }
+
+ //OpPostfix:
+ // "++" | "--";
+ public XbaseGrammarAccess.OpPostfixElements getOpPostfixAccess() {
+ return gaXbase.getOpPostfixAccess();
+ }
+
+ public ParserRule getOpPostfixRule() {
+ return getOpPostfixAccess().getRule();
+ }
+
+ //XMemberFeatureCall XExpression:
+ // XPrimaryExpression (=> ({XAssignment.assignable=current} ('.' | explicitStatic?="::")
+ // feature=[types::JvmIdentifiableElement|FeatureCallID] OpSingleAssign) value=XAssignment
+ // | => ({XMemberFeatureCall.memberCallTarget=current} ("." | nullSafe?="?." | explicitStatic?="::")) ('<'
+ // typeArguments+=JvmArgumentTypeReference (',' typeArguments+=JvmArgumentTypeReference)* '>')?
+ // feature=[types::JvmIdentifiableElement|IdOrSuper] (=> explicitOperationCall?='(' (memberCallArguments+=XShortClosure
+ // | memberCallArguments+=XExpression (',' memberCallArguments+=XExpression)*)?
+ // ')')?
+ // memberCallArguments+=XClosure?)*;
+ public XbaseGrammarAccess.XMemberFeatureCallElements getXMemberFeatureCallAccess() {
+ return gaXbase.getXMemberFeatureCallAccess();
+ }
+
+ public ParserRule getXMemberFeatureCallRule() {
+ return getXMemberFeatureCallAccess().getRule();
+ }
+
+ //XPrimaryExpression XExpression:
+ // XConstructorCall | XBlockExpression | XSwitchExpression | XSynchronizedExpression | XFeatureCall | XLiteral |
+ // XIfExpression | XForLoopExpression | XBasicForLoopExpression | XWhileExpression | XDoWhileExpression |
+ // XThrowExpression | XReturnExpression | XTryCatchFinallyExpression | XParenthesizedExpression;
+ public XbaseGrammarAccess.XPrimaryExpressionElements getXPrimaryExpressionAccess() {
+ return gaXbase.getXPrimaryExpressionAccess();
+ }
+
+ public ParserRule getXPrimaryExpressionRule() {
+ return getXPrimaryExpressionAccess().getRule();
+ }
+
+ //XLiteral XExpression:
+ // XCollectionLiteral | XClosure | XBooleanLiteral | XNumberLiteral | XNullLiteral | XStringLiteral | XTypeLiteral;
+ public XbaseGrammarAccess.XLiteralElements getXLiteralAccess() {
+ return gaXbase.getXLiteralAccess();
+ }
+
+ public ParserRule getXLiteralRule() {
+ return getXLiteralAccess().getRule();
+ }
+
+ //XCollectionLiteral:
+ // XSetLiteral | XListLiteral;
+ public XbaseGrammarAccess.XCollectionLiteralElements getXCollectionLiteralAccess() {
+ return gaXbase.getXCollectionLiteralAccess();
+ }
+
+ public ParserRule getXCollectionLiteralRule() {
+ return getXCollectionLiteralAccess().getRule();
+ }
+
+ //XSetLiteral:
+ // {XSetLiteral} '#' '{' (elements+=XExpression (',' elements+=XExpression)*)? '}';
+ public XbaseGrammarAccess.XSetLiteralElements getXSetLiteralAccess() {
+ return gaXbase.getXSetLiteralAccess();
+ }
+
+ public ParserRule getXSetLiteralRule() {
+ return getXSetLiteralAccess().getRule();
+ }
+
+ //XListLiteral:
+ // {XListLiteral} '#' '[' (elements+=XExpression (',' elements+=XExpression)*)? ']';
+ public XbaseGrammarAccess.XListLiteralElements getXListLiteralAccess() {
+ return gaXbase.getXListLiteralAccess();
+ }
+
+ public ParserRule getXListLiteralRule() {
+ return getXListLiteralAccess().getRule();
+ }
+
+ //XClosure XExpression:
+ // => ({XClosure}
+ // '[')
+ // => ((declaredFormalParameters+=JvmFormalParameter (',' declaredFormalParameters+=JvmFormalParameter)*)?
+ // explicitSyntax?='|')?
+ // expression=XExpressionInClosure
+ // ']';
+ public XbaseGrammarAccess.XClosureElements getXClosureAccess() {
+ return gaXbase.getXClosureAccess();
+ }
+
+ public ParserRule getXClosureRule() {
+ return getXClosureAccess().getRule();
+ }
+
+ //XExpressionInClosure XExpression:
+ // {XBlockExpression} (expressions+=XExpressionOrVarDeclaration ';'?)*;
+ public XbaseGrammarAccess.XExpressionInClosureElements getXExpressionInClosureAccess() {
+ return gaXbase.getXExpressionInClosureAccess();
+ }
+
+ public ParserRule getXExpressionInClosureRule() {
+ return getXExpressionInClosureAccess().getRule();
+ }
+
+ //XShortClosure XExpression:
+ // => ({XClosure} (declaredFormalParameters+=JvmFormalParameter (',' declaredFormalParameters+=JvmFormalParameter)*)?
+ // explicitSyntax?='|') expression=XExpression;
+ public XbaseGrammarAccess.XShortClosureElements getXShortClosureAccess() {
+ return gaXbase.getXShortClosureAccess();
+ }
+
+ public ParserRule getXShortClosureRule() {
+ return getXShortClosureAccess().getRule();
+ }
+
+ //XParenthesizedExpression XExpression:
+ // '(' XExpression ')';
+ public XbaseGrammarAccess.XParenthesizedExpressionElements getXParenthesizedExpressionAccess() {
+ return gaXbase.getXParenthesizedExpressionAccess();
+ }
+
+ public ParserRule getXParenthesizedExpressionRule() {
+ return getXParenthesizedExpressionAccess().getRule();
+ }
+
+ //XIfExpression XExpression:
+ // {XIfExpression}
+ // 'if' '(' if=XExpression ')'
+ // then=XExpression (=> 'else' else=XExpression)?;
+ public XbaseGrammarAccess.XIfExpressionElements getXIfExpressionAccess() {
+ return gaXbase.getXIfExpressionAccess();
+ }
+
+ public ParserRule getXIfExpressionRule() {
+ return getXIfExpressionAccess().getRule();
+ }
+
+ //XSwitchExpression XExpression:
+ // {XSwitchExpression}
+ // 'switch' (=> ('(' declaredParam=JvmFormalParameter ':') switch=XExpression ')'
+ // | => (declaredParam=JvmFormalParameter ':')? switch=XExpression) '{'
+ // cases+=XCasePart* ('default' ':' default=XExpression)?
+ // '}';
+ public XbaseGrammarAccess.XSwitchExpressionElements getXSwitchExpressionAccess() {
+ return gaXbase.getXSwitchExpressionAccess();
+ }
+
+ public ParserRule getXSwitchExpressionRule() {
+ return getXSwitchExpressionAccess().getRule();
+ }
+
+ //XCasePart:
+ // {XCasePart} typeGuard=JvmTypeReference? ('case' case=XExpression)? (':' then=XExpression | fallThrough?=',');
+ public XbaseGrammarAccess.XCasePartElements getXCasePartAccess() {
+ return gaXbase.getXCasePartAccess();
+ }
+
+ public ParserRule getXCasePartRule() {
+ return getXCasePartAccess().getRule();
+ }
+
+ //XForLoopExpression XExpression:
+ // => ({XForLoopExpression}
+ // 'for' '(' declaredParam=JvmFormalParameter ':') forExpression=XExpression ')'
+ // eachExpression=XExpression;
+ public XbaseGrammarAccess.XForLoopExpressionElements getXForLoopExpressionAccess() {
+ return gaXbase.getXForLoopExpressionAccess();
+ }
+
+ public ParserRule getXForLoopExpressionRule() {
+ return getXForLoopExpressionAccess().getRule();
+ }
+
+ //XBasicForLoopExpression XExpression:
+ // {XBasicForLoopExpression}
+ // 'for' '(' (initExpressions+=XExpressionOrVarDeclaration (',' initExpressions+=XExpressionOrVarDeclaration)*)? ';'
+ // expression=XExpression? ';' (updateExpressions+=XExpression (',' updateExpressions+=XExpression)*)? ')'
+ // eachExpression=XExpression;
+ public XbaseGrammarAccess.XBasicForLoopExpressionElements getXBasicForLoopExpressionAccess() {
+ return gaXbase.getXBasicForLoopExpressionAccess();
+ }
+
+ public ParserRule getXBasicForLoopExpressionRule() {
+ return getXBasicForLoopExpressionAccess().getRule();
+ }
+
+ //XWhileExpression XExpression:
+ // {XWhileExpression}
+ // 'while' '(' predicate=XExpression ')'
+ // body=XExpression;
+ public XbaseGrammarAccess.XWhileExpressionElements getXWhileExpressionAccess() {
+ return gaXbase.getXWhileExpressionAccess();
+ }
+
+ public ParserRule getXWhileExpressionRule() {
+ return getXWhileExpressionAccess().getRule();
+ }
+
+ //XDoWhileExpression XExpression:
+ // {XDoWhileExpression}
+ // 'do'
+ // body=XExpression
+ // 'while' '(' predicate=XExpression ')';
+ public XbaseGrammarAccess.XDoWhileExpressionElements getXDoWhileExpressionAccess() {
+ return gaXbase.getXDoWhileExpressionAccess();
+ }
+
+ public ParserRule getXDoWhileExpressionRule() {
+ return getXDoWhileExpressionAccess().getRule();
+ }
+
+ //XBlockExpression XExpression:
+ // {XBlockExpression}
+ // '{' (expressions+=XExpressionOrVarDeclaration ';'?)*
+ // '}';
+ public XbaseGrammarAccess.XBlockExpressionElements getXBlockExpressionAccess() {
+ return gaXbase.getXBlockExpressionAccess();
+ }
+
+ public ParserRule getXBlockExpressionRule() {
+ return getXBlockExpressionAccess().getRule();
+ }
+
+ //XExpressionOrVarDeclaration XExpression:
+ // XVariableDeclaration | XExpression;
+ public XbaseGrammarAccess.XExpressionOrVarDeclarationElements getXExpressionOrVarDeclarationAccess() {
+ return gaXbase.getXExpressionOrVarDeclarationAccess();
+ }
+
+ public ParserRule getXExpressionOrVarDeclarationRule() {
+ return getXExpressionOrVarDeclarationAccess().getRule();
+ }
+
+ //XVariableDeclaration XExpression:
+ // {XVariableDeclaration} (writeable?='var' | 'val') (=> (type=JvmTypeReference name=ValidID) | name=ValidID) ('='
+ // right=XExpression)?;
+ public XbaseGrammarAccess.XVariableDeclarationElements getXVariableDeclarationAccess() {
+ return gaXbase.getXVariableDeclarationAccess();
+ }
+
+ public ParserRule getXVariableDeclarationRule() {
+ return getXVariableDeclarationAccess().getRule();
+ }
+
+ //JvmFormalParameter types::JvmFormalParameter:
+ // parameterType=JvmTypeReference? name=ValidID;
+ public XbaseGrammarAccess.JvmFormalParameterElements getJvmFormalParameterAccess() {
+ return gaXbase.getJvmFormalParameterAccess();
+ }
+
+ public ParserRule getJvmFormalParameterRule() {
+ return getJvmFormalParameterAccess().getRule();
+ }
+
+ //FullJvmFormalParameter types::JvmFormalParameter:
+ // parameterType=JvmTypeReference name=ValidID;
+ public XbaseGrammarAccess.FullJvmFormalParameterElements getFullJvmFormalParameterAccess() {
+ return gaXbase.getFullJvmFormalParameterAccess();
+ }
+
+ public ParserRule getFullJvmFormalParameterRule() {
+ return getFullJvmFormalParameterAccess().getRule();
+ }
+
+ //XFeatureCall XExpression:
+ // {XFeatureCall} ('<' typeArguments+=JvmArgumentTypeReference (',' typeArguments+=JvmArgumentTypeReference)* '>')?
+ // feature=[types::JvmIdentifiableElement|IdOrSuper] (=> explicitOperationCall?='(' (featureCallArguments+=XShortClosure
+ // | featureCallArguments+=XExpression (',' featureCallArguments+=XExpression)*)?
+ // ')')?
+ // featureCallArguments+=XClosure?;
+ public XbaseGrammarAccess.XFeatureCallElements getXFeatureCallAccess() {
+ return gaXbase.getXFeatureCallAccess();
+ }
+
+ public ParserRule getXFeatureCallRule() {
+ return getXFeatureCallAccess().getRule();
+ }
+
+ //FeatureCallID:
+ // ValidID | 'extends' | 'static' | 'import' | 'extension';
+ public XbaseGrammarAccess.FeatureCallIDElements getFeatureCallIDAccess() {
+ return gaXbase.getFeatureCallIDAccess();
+ }
+
+ public ParserRule getFeatureCallIDRule() {
+ return getFeatureCallIDAccess().getRule();
+ }
+
+ //IdOrSuper:
+ // FeatureCallID | 'super';
+ public XbaseGrammarAccess.IdOrSuperElements getIdOrSuperAccess() {
+ return gaXbase.getIdOrSuperAccess();
+ }
+
+ public ParserRule getIdOrSuperRule() {
+ return getIdOrSuperAccess().getRule();
+ }
+
+ //XConstructorCall XExpression:
+ // {XConstructorCall}
+ // 'new' constructor=[types::JvmConstructor|QualifiedName] (=> '<' typeArguments+=JvmArgumentTypeReference (','
+ // typeArguments+=JvmArgumentTypeReference)* '>')? (=> explicitConstructorCall?='(' (arguments+=XShortClosure
+ // | arguments+=XExpression (',' arguments+=XExpression)*)?
+ // ')')?
+ // arguments+=XClosure?;
+ public XbaseGrammarAccess.XConstructorCallElements getXConstructorCallAccess() {
+ return gaXbase.getXConstructorCallAccess();
+ }
+
+ public ParserRule getXConstructorCallRule() {
+ return getXConstructorCallAccess().getRule();
+ }
+
+ //XBooleanLiteral XExpression:
+ // {XBooleanLiteral} ('false' | isTrue?='true');
+ public XbaseGrammarAccess.XBooleanLiteralElements getXBooleanLiteralAccess() {
+ return gaXbase.getXBooleanLiteralAccess();
+ }
+
+ public ParserRule getXBooleanLiteralRule() {
+ return getXBooleanLiteralAccess().getRule();
+ }
+
+ //XNullLiteral XExpression:
+ // {XNullLiteral} 'null';
+ public XbaseGrammarAccess.XNullLiteralElements getXNullLiteralAccess() {
+ return gaXbase.getXNullLiteralAccess();
+ }
+
+ public ParserRule getXNullLiteralRule() {
+ return getXNullLiteralAccess().getRule();
+ }
+
+ //XNumberLiteral XExpression:
+ // {XNumberLiteral} value=Number;
+ public XbaseGrammarAccess.XNumberLiteralElements getXNumberLiteralAccess() {
+ return gaXbase.getXNumberLiteralAccess();
+ }
+
+ public ParserRule getXNumberLiteralRule() {
+ return getXNumberLiteralAccess().getRule();
+ }
+
+ //XStringLiteral XExpression:
+ // {XStringLiteral} value=STRING;
+ public XbaseGrammarAccess.XStringLiteralElements getXStringLiteralAccess() {
+ return gaXbase.getXStringLiteralAccess();
+ }
+
+ public ParserRule getXStringLiteralRule() {
+ return getXStringLiteralAccess().getRule();
+ }
+
+ //XTypeLiteral XExpression:
+ // {XTypeLiteral} 'typeof' '(' type=[types::JvmType|QualifiedName] arrayDimensions+=ArrayBrackets* ')';
+ public XbaseGrammarAccess.XTypeLiteralElements getXTypeLiteralAccess() {
+ return gaXbase.getXTypeLiteralAccess();
+ }
+
+ public ParserRule getXTypeLiteralRule() {
+ return getXTypeLiteralAccess().getRule();
+ }
+
+ //XThrowExpression XExpression:
+ // {XThrowExpression} 'throw' expression=XExpression;
+ public XbaseGrammarAccess.XThrowExpressionElements getXThrowExpressionAccess() {
+ return gaXbase.getXThrowExpressionAccess();
+ }
+
+ public ParserRule getXThrowExpressionRule() {
+ return getXThrowExpressionAccess().getRule();
+ }
+
+ //XReturnExpression XExpression:
+ // {XReturnExpression} 'return' -> expression=XExpression?;
+ public XbaseGrammarAccess.XReturnExpressionElements getXReturnExpressionAccess() {
+ return gaXbase.getXReturnExpressionAccess();
+ }
+
+ public ParserRule getXReturnExpressionRule() {
+ return getXReturnExpressionAccess().getRule();
+ }
+
+ //XTryCatchFinallyExpression XExpression:
+ // {XTryCatchFinallyExpression}
+ // 'try'
+ // expression=XExpression (catchClauses+=XCatchClause+ (=> 'finally' finallyExpression=XExpression)?
+ // | 'finally' finallyExpression=XExpression);
+ public XbaseGrammarAccess.XTryCatchFinallyExpressionElements getXTryCatchFinallyExpressionAccess() {
+ return gaXbase.getXTryCatchFinallyExpressionAccess();
+ }
+
+ public ParserRule getXTryCatchFinallyExpressionRule() {
+ return getXTryCatchFinallyExpressionAccess().getRule();
+ }
+
+ //XSynchronizedExpression XExpression:
+ // => ({XSynchronizedExpression}
+ // 'synchronized' '(') param=XExpression ')' expression=XExpression;
+ public XbaseGrammarAccess.XSynchronizedExpressionElements getXSynchronizedExpressionAccess() {
+ return gaXbase.getXSynchronizedExpressionAccess();
+ }
+
+ public ParserRule getXSynchronizedExpressionRule() {
+ return getXSynchronizedExpressionAccess().getRule();
+ }
+
+ //XCatchClause:
+ // => 'catch' '(' declaredParam=FullJvmFormalParameter ')' expression=XExpression;
+ public XbaseGrammarAccess.XCatchClauseElements getXCatchClauseAccess() {
+ return gaXbase.getXCatchClauseAccess();
+ }
+
+ public ParserRule getXCatchClauseRule() {
+ return getXCatchClauseAccess().getRule();
+ }
+
+ //QualifiedName:
+ // ValidID (=> '.' ValidID)*;
+ public XbaseGrammarAccess.QualifiedNameElements getQualifiedNameAccess() {
+ return gaXbase.getQualifiedNameAccess();
+ }
+
+ public ParserRule getQualifiedNameRule() {
+ return getQualifiedNameAccess().getRule();
+ }
+
+ //Number hidden():
+ // HEX | (INT | DECIMAL) ('.' (INT | DECIMAL))?;
+ public XbaseGrammarAccess.NumberElements getNumberAccess() {
+ return gaXbase.getNumberAccess();
+ }
+
+ public ParserRule getNumberRule() {
+ return getNumberAccess().getRule();
+ }
+
+ ///**
+ // * Dummy rule, for "better" downwards compatibility, since GrammarAccess generates non-static inner classes,
+ // * which makes downstream grammars break on classloading, when a rule is removed.
+ // */ StaticQualifier:
+ // (ValidID '::')+;
+ public XbaseGrammarAccess.StaticQualifierElements getStaticQualifierAccess() {
+ return gaXbase.getStaticQualifierAccess();
+ }
+
+ public ParserRule getStaticQualifierRule() {
+ return getStaticQualifierAccess().getRule();
+ }
+
+ //terminal HEX:
+ // ('0x' | '0X') ('0'..'9' | 'a'..'f' | 'A'..'F' | '_')+ ('#' (('b' | 'B') ('i' | 'I') | ('l' | 'L')))?;
+ public TerminalRule getHEXRule() {
+ return gaXbase.getHEXRule();
+ }
+
+ //terminal INT returns ecore::EInt:
+ // '0'..'9' ('0'..'9' | '_')*;
+ public TerminalRule getINTRule() {
+ return gaXbase.getINTRule();
+ }
+
+ //terminal DECIMAL:
+ // INT (('e' | 'E') ('+' | '-')? INT)? (('b' | 'B') ('i' | 'I' | 'd' | 'D') | ('l' | 'L' | 'd' | 'D' | 'f' | 'F'))?;
+ public TerminalRule getDECIMALRule() {
+ return gaXbase.getDECIMALRule();
+ }
+
+ //JvmTypeReference:
+ // JvmParameterizedTypeReference => ({JvmGenericArrayTypeReference.componentType=current} ArrayBrackets)*
+ // | XFunctionTypeRef;
+ public XtypeGrammarAccess.JvmTypeReferenceElements getJvmTypeReferenceAccess() {
+ return gaXtype.getJvmTypeReferenceAccess();
+ }
+
+ public ParserRule getJvmTypeReferenceRule() {
+ return getJvmTypeReferenceAccess().getRule();
+ }
+
+ //ArrayBrackets:
+ // '[' ']';
+ public XtypeGrammarAccess.ArrayBracketsElements getArrayBracketsAccess() {
+ return gaXtype.getArrayBracketsAccess();
+ }
+
+ public ParserRule getArrayBracketsRule() {
+ return getArrayBracketsAccess().getRule();
+ }
+
+ //XFunctionTypeRef:
+ // ('(' (paramTypes+=JvmTypeReference (',' paramTypes+=JvmTypeReference)*)? ')')? '=>' returnType=JvmTypeReference;
+ public XtypeGrammarAccess.XFunctionTypeRefElements getXFunctionTypeRefAccess() {
+ return gaXtype.getXFunctionTypeRefAccess();
+ }
+
+ public ParserRule getXFunctionTypeRefRule() {
+ return getXFunctionTypeRefAccess().getRule();
+ }
+
+ //JvmParameterizedTypeReference:
+ // type=[JvmType|super::QualifiedName] (=> '<' arguments+=JvmArgumentTypeReference (','
+ // arguments+=JvmArgumentTypeReference)* '>' (=> ({JvmInnerTypeReference.outer=current} '.') type=[JvmType|ValidID] (=>
+ // '<' arguments+=JvmArgumentTypeReference (',' arguments+=JvmArgumentTypeReference)* '>')?)*)?;
+ public XtypeGrammarAccess.JvmParameterizedTypeReferenceElements getJvmParameterizedTypeReferenceAccess() {
+ return gaXtype.getJvmParameterizedTypeReferenceAccess();
+ }
+
+ public ParserRule getJvmParameterizedTypeReferenceRule() {
+ return getJvmParameterizedTypeReferenceAccess().getRule();
+ }
+
+ //JvmArgumentTypeReference JvmTypeReference:
+ // JvmTypeReference | JvmWildcardTypeReference;
+ public XtypeGrammarAccess.JvmArgumentTypeReferenceElements getJvmArgumentTypeReferenceAccess() {
+ return gaXtype.getJvmArgumentTypeReferenceAccess();
+ }
+
+ public ParserRule getJvmArgumentTypeReferenceRule() {
+ return getJvmArgumentTypeReferenceAccess().getRule();
+ }
+
+ //JvmWildcardTypeReference:
+ // {JvmWildcardTypeReference} '?' (constraints+=JvmUpperBound constraints+=JvmUpperBoundAnded*
+ // | constraints+=JvmLowerBound constraints+=JvmLowerBoundAnded*)?;
+ public XtypeGrammarAccess.JvmWildcardTypeReferenceElements getJvmWildcardTypeReferenceAccess() {
+ return gaXtype.getJvmWildcardTypeReferenceAccess();
+ }
+
+ public ParserRule getJvmWildcardTypeReferenceRule() {
+ return getJvmWildcardTypeReferenceAccess().getRule();
+ }
+
+ //JvmUpperBound:
+ // 'extends' typeReference=JvmTypeReference;
+ public XtypeGrammarAccess.JvmUpperBoundElements getJvmUpperBoundAccess() {
+ return gaXtype.getJvmUpperBoundAccess();
+ }
+
+ public ParserRule getJvmUpperBoundRule() {
+ return getJvmUpperBoundAccess().getRule();
+ }
+
+ //JvmUpperBoundAnded JvmUpperBound:
+ // '&' typeReference=JvmTypeReference;
+ public XtypeGrammarAccess.JvmUpperBoundAndedElements getJvmUpperBoundAndedAccess() {
+ return gaXtype.getJvmUpperBoundAndedAccess();
+ }
+
+ public ParserRule getJvmUpperBoundAndedRule() {
+ return getJvmUpperBoundAndedAccess().getRule();
+ }
+
+ //JvmLowerBound:
+ // 'super' typeReference=JvmTypeReference;
+ public XtypeGrammarAccess.JvmLowerBoundElements getJvmLowerBoundAccess() {
+ return gaXtype.getJvmLowerBoundAccess();
+ }
+
+ public ParserRule getJvmLowerBoundRule() {
+ return getJvmLowerBoundAccess().getRule();
+ }
+
+ //JvmLowerBoundAnded JvmLowerBound:
+ // '&' typeReference=JvmTypeReference;
+ public XtypeGrammarAccess.JvmLowerBoundAndedElements getJvmLowerBoundAndedAccess() {
+ return gaXtype.getJvmLowerBoundAndedAccess();
+ }
+
+ public ParserRule getJvmLowerBoundAndedRule() {
+ return getJvmLowerBoundAndedAccess().getRule();
+ }
+
+ //JvmTypeParameter:
+ // name=ValidID (constraints+=JvmUpperBound constraints+=JvmUpperBoundAnded*)?;
+ public XtypeGrammarAccess.JvmTypeParameterElements getJvmTypeParameterAccess() {
+ return gaXtype.getJvmTypeParameterAccess();
+ }
+
+ public ParserRule getJvmTypeParameterRule() {
+ return getJvmTypeParameterAccess().getRule();
+ }
+
+ //QualifiedNameWithWildcard:
+ // super::QualifiedName '.' '*';
+ public XtypeGrammarAccess.QualifiedNameWithWildcardElements getQualifiedNameWithWildcardAccess() {
+ return gaXtype.getQualifiedNameWithWildcardAccess();
+ }
+
+ public ParserRule getQualifiedNameWithWildcardRule() {
+ return getQualifiedNameWithWildcardAccess().getRule();
+ }
+
+ //ValidID:
+ // ID;
+ public XtypeGrammarAccess.ValidIDElements getValidIDAccess() {
+ return gaXtype.getValidIDAccess();
+ }
+
+ public ParserRule getValidIDRule() {
+ return getValidIDAccess().getRule();
+ }
+
+ //XImportSection:
+ // importDeclarations+=super::XImportDeclaration+;
+ public XtypeGrammarAccess.XImportSectionElements getXImportSectionAccess() {
+ return gaXtype.getXImportSectionAccess();
+ }
+
+ public ParserRule getXImportSectionRule() {
+ return getXImportSectionAccess().getRule();
+ }
+
+ //QualifiedNameInStaticImport:
+ // (ValidID '.')+;
+ public XtypeGrammarAccess.QualifiedNameInStaticImportElements getQualifiedNameInStaticImportAccess() {
+ return gaXtype.getQualifiedNameInStaticImportAccess();
+ }
+
+ public ParserRule getQualifiedNameInStaticImportRule() {
+ return getQualifiedNameInStaticImportAccess().getRule();
+ }
+
+ //terminal ID:
+ // '^'? ('a'..'z' | 'A'..'Z' | '$' | '_') ('a'..'z' | 'A'..'Z' | '$' | '_' | '0'..'9')*;
+ public TerminalRule getIDRule() {
+ return gaXtype.getIDRule();
+ }
+
+ //terminal STRING:
+ // '"' ('\\' . | !('\\' | '"'))* '"'? |
+ // "'" ('\\' . | !('\\' | "'"))* "'"?;
+ public TerminalRule getSTRINGRule() {
+ return gaXtype.getSTRINGRule();
+ }
+
+ //terminal ML_COMMENT:
+ // '/*'->'*/';
+ public TerminalRule getML_COMMENTRule() {
+ return gaXtype.getML_COMMENTRule();
+ }
+
+ //terminal SL_COMMENT:
+ // '//' !('\n' | '\r')* ('\r'? '\n')?;
+ public TerminalRule getSL_COMMENTRule() {
+ return gaXtype.getSL_COMMENTRule();
+ }
+
+ //terminal WS:
+ // ' ' | '\t' | '\r' | '\n'+;
+ public TerminalRule getWSRule() {
+ return gaXtype.getWSRule();
+ }
+
+ //terminal ANY_OTHER:
+ // .;
+ public TerminalRule getANY_OTHERRule() {
+ return gaXtype.getANY_OTHERRule();
+ }
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/validation/AbstractOXtypeValidator.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/validation/AbstractOXtypeValidator.java
new file mode 100644
index 0000000..58c9c63
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/validation/AbstractOXtypeValidator.java
@@ -0,0 +1,24 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.validation;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.xtext.xbase.annotations.validation.XbaseWithAnnotationsValidator;
+
+public abstract class AbstractOXtypeValidator extends XbaseWithAnnotationsValidator {
+
+ @Override
+ protected List<EPackage> getEPackages() {
+ List<EPackage> result = new ArrayList<EPackage>(super.getEPackages());
+ result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/osbp/xtext/oxtype/OXtype"));
+ result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/Xtext/Xbase/XAnnotations"));
+ result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/xtext/xbase/Xbase"));
+ result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/xtext/common/JavaVMTypes"));
+ result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/xtext/xbase/Xtype"));
+ return result;
+ }
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/GenerateOXtype.mwe2 b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/GenerateOXtype.mwe2
new file mode 100644
index 0000000..48f0972
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/GenerateOXtype.mwe2
@@ -0,0 +1,50 @@
+module org.eclipse.osbp.xtext.oxtype.GenerateOXtype
+
+import org.eclipse.xtext.xtext.generator.*
+import org.eclipse.xtext.xtext.generator.model.project.*
+
+var rootPath = ".."
+var runtimeProjectName = "org.eclipse.osbp.xtext.oxtype"
+var projectPath = "${rootPath}/${runtimeProjectName}"
+
+Workflow {
+
+ component = XtextGenerator {
+ configuration = {
+ project = StandardProjectConfig {
+ baseName = "org.eclipse.osbp.xtext.oxtype"
+ rootPath = rootPath
+ runtimeTest = {
+ enabled = true
+ }
+ eclipsePlugin = {
+ enabled = true
+ }
+ eclipsePluginTest = {
+ enabled = true
+ }
+ createEclipseMetaData = true
+ }
+
+ code = {
+ encoding = "UTF-8"
+ lineDelimiter = "\n"
+ fileHeader = "/*\n * generated by Xtext \${version}\n */"
+ }
+ }
+ language = StandardLanguage {
+ resourceSet = org.eclipse.xtext.resource.XtextResourceSet : resourceSet {}
+ referencedResource = "platform:/resource/${runtimeProjectName}/model/OXtype.genmodel"
+ name = "org.eclipse.osbp.xtext.oxtype.OXtype"
+ fileExtensions = "oxtype"
+
+ serializer = {
+ generateStub = false
+ }
+
+ validator = {
+ // composedCheck = "org.eclipse.xtext.validation.NamesAreUniqueValidator"
+ }
+ }
+ }
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtype.xtext b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtype.xtext
new file mode 100644
index 0000000..4294255
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtype.xtext
@@ -0,0 +1,15 @@
+grammar org.eclipse.osbp.xtext.oxtype.OXtype with org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations
+
+import "http://www.eclipse.org/xtext/xbase/Xtype"
+import "http://www.eclipse.org/xtext/common/JavaVMTypes"
+import "http://www.eclipse.org/osbp/xtext/oxtype/OXtype"
+
+@Override
+XImportDeclaration returns OXImportDeclaration:
+ {OXImportDeclaration}
+ 'import' (
+ (static?='static' extension?='extension'? importedType=[JvmDeclaredType|QualifiedNameInStaticImport] (wildcard?='*' | memberName=ValidID))
+ | importedType=[JvmDeclaredType|QualifiedName]
+ | importedNamespace=QualifiedNameWithWildcard
+ | fqnImport?='ns' importedFullyQualifiedName=QualifiedName) ';'?
+;
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtypeRuntimeModule.xtend b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtypeRuntimeModule.xtend
new file mode 100644
index 0000000..6cdee2e
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtypeRuntimeModule.xtend
@@ -0,0 +1,11 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype
+
+
+/**
+ * Use this class to register components to be used at runtime / without the Equinox extension registry.
+ */
+class OXtypeRuntimeModule extends AbstractOXtypeRuntimeModule {
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtypeStandaloneSetup.xtend b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtypeStandaloneSetup.xtend
new file mode 100644
index 0000000..b2c9628
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtypeStandaloneSetup.xtend
@@ -0,0 +1,15 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype
+
+
+/**
+ * Initialization support for running Xtext languages without Equinox extension registry.
+ */
+class OXtypeStandaloneSetup extends OXtypeStandaloneSetupGenerated {
+
+ def static void doSetup() {
+ new OXtypeStandaloneSetup().createInjectorAndDoEMFRegistration()
+ }
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/jvmmodel/OXtypeJvmModelInferrer.xtend b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/jvmmodel/OXtypeJvmModelInferrer.xtend
new file mode 100644
index 0000000..3071fda
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/jvmmodel/OXtypeJvmModelInferrer.xtend
@@ -0,0 +1,62 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.jvmmodel
+
+import com.google.inject.Inject
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration
+import org.eclipse.xtext.xbase.jvmmodel.AbstractModelInferrer
+import org.eclipse.xtext.xbase.jvmmodel.IJvmDeclaredTypeAcceptor
+import org.eclipse.xtext.xbase.jvmmodel.JvmTypesBuilder
+
+/**
+ * <p>Infers a JVM model from the source model.</p>
+ *
+ * <p>The JVM model should contain all elements that would appear in the Java code
+ * which is generated from the source model. Other models link against the JVM model rather than the source model.</p>
+ */
+class OXtypeJvmModelInferrer extends AbstractModelInferrer {
+
+ /**
+ * convenience API to build and initialize JVM types and their members.
+ */
+ @Inject extension JvmTypesBuilder
+
+ /**
+ * The dispatch method {@code infer} is called for each instance of the
+ * given element's type that is contained in a resource.
+ *
+ * @param element
+ * the model to create one or more
+ * {@link org.eclipse.xtext.common.types.JvmDeclaredType declared
+ * types} from.
+ * @param acceptor
+ * each created
+ * {@link org.eclipse.xtext.common.types.JvmDeclaredType type}
+ * without a container should be passed to the acceptor in order
+ * get attached to the current resource. The acceptor's
+ * {@link IJvmDeclaredTypeAcceptor#accept(org.eclipse.xtext.common.types.JvmDeclaredType)
+ * accept(..)} method takes the constructed empty type for the
+ * pre-indexing phase. This one is further initialized in the
+ * indexing phase using the lambda you pass as the last argument.
+ * @param isPreIndexingPhase
+ * whether the method is called in a pre-indexing phase, i.e.
+ * when the global index is not yet fully updated. You must not
+ * rely on linking using the index if isPreIndexingPhase is
+ * <code>true</code>.
+ */
+ def dispatch void infer(OXImportDeclaration element, IJvmDeclaredTypeAcceptor acceptor, boolean isPreIndexingPhase) {
+ // Here you explain how your model is mapped to Java elements, by writing the actual translation code.
+
+ // An implementation for the initial hello world example could look like this:
+// acceptor.accept(element.toClass("my.company.greeting.MyGreetings")) [
+// for (greeting : element.greetings) {
+// members += greeting.toMethod("hello" + greeting.name, typeRef(String)) [
+// body = '''
+// return "Hello «greeting.name»";
+// '''
+// ]
+// }
+// ]
+ }
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/linking/LazyJvmTypeLinker.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/linking/LazyJvmTypeLinker.java
new file mode 100644
index 0000000..aaea2e8
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/linking/LazyJvmTypeLinker.java
@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Florian Pirchner - Initial implementation
+ */
+package org.eclipse.osbp.xtext.oxtype.linking;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.xtext.common.types.JvmParameterizedTypeReference;
+import org.eclipse.xtext.common.types.JvmType;
+import org.eclipse.xtext.common.types.TypesFactory;
+import org.eclipse.xtext.common.types.TypesPackage;
+import org.eclipse.xtext.nodemodel.INode;
+import org.eclipse.xtext.xbase.linking.XbaseLazyLinker;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.inject.Inject;
+
+@SuppressWarnings("restriction")
+public class LazyJvmTypeLinker extends XbaseLazyLinker {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(LazyJvmTypeLinker.class);
+
+ @Inject
+ private LazyJvmTypeLinkingHelper jvmLinkingHelper;
+
+ @Override
+ protected void clearReference(EObject obj, EReference ref) {
+ if (jvmLinkingHelper.isJvmLink((EReference) obj.eContainingFeature())) {
+ // do not clear this reference
+ return;
+ }
+
+ super.clearReference(obj, ref);
+ }
+
+ @SuppressWarnings("unchecked")
+ protected void createAndSetProxy(EObject obj, INode node, EReference eRef) {
+ if (jvmLinkingHelper.isJvmLink(eRef)) {
+ return;
+ }
+
+ EObject proxy = createProxy(obj, node, eRef);
+ if (eRef.isMany()) {
+ ((InternalEList<EObject>) obj.eGet(eRef, false)).addUnique(proxy);
+ } else {
+ obj.eSet(eRef, proxy);
+ }
+
+ if (jvmLinkingHelper.needsJvmLinking(eRef)) {
+ for (EReference jvmLinkReference : jvmLinkingHelper.getJvmLinkingReferences(eRef)) {
+ final JvmParameterizedTypeReference typeRef = TypesFactory.eINSTANCE
+ .createJvmParameterizedTypeReference();
+ if (eRef.isMany()) {
+ ((InternalEList<EObject>) obj.eGet(jvmLinkReference, false)).addUnique(typeRef);
+ } else {
+ obj.eSet(jvmLinkReference, typeRef);
+ }
+
+ final JvmType jvmProxy = (JvmType) createProxy(typeRef, node,
+ TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE);
+ typeRef.setType(jvmProxy);
+
+ LazyJvmTypeLinkingHelper.IJvmTypeRefFinisher finisher = jvmLinkingHelper.getFinisher(jvmLinkReference);
+ if (finisher != null) {
+ finisher.finish(jvmLinkReference, typeRef);
+ }
+ }
+ }
+ }
+
+ /**
+ * Unique name of representation.
+ *
+ * @param referenceType
+ * @param crossReferenceString
+ * @return
+ */
+ private String createProxyAccess(EClass referenceType, String crossReferenceString) {
+ return String.format("%s.%s.%s", referenceType.getEPackage().getNsURI(), referenceType.getName(),
+ crossReferenceString);
+ }
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/linking/LazyJvmTypeLinkingHelper.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/linking/LazyJvmTypeLinkingHelper.java
new file mode 100644
index 0000000..c3fc945
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/linking/LazyJvmTypeLinkingHelper.java
@@ -0,0 +1,204 @@
+/**
+ * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Florian Pirchner - Initial implementation
+ */
+package org.eclipse.osbp.xtext.oxtype.linking;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.xtext.common.types.JvmTypeReference;
+
+// TODO: Auto-generated Javadoc
+/**
+ * A helper class to register jvmLinkingReferences.
+ */
+public class LazyJvmTypeLinkingHelper {
+
+ /** The link mappings. */
+ private Map<EReference, Set<EReference>> linkMappings = new HashMap<EReference, Set<EReference>>();
+
+ /** The jvm link to enhancers. */
+ private Map<EReference, IJvmLinkCrossRefStringEnhancer> jvmLinkToEnhancers = new HashMap<EReference, IJvmLinkCrossRefStringEnhancer>();
+
+ /** The jvm link to finisher. */
+ private Map<EReference, IJvmTypeRefFinisher> jvmLinkToFinisher = new HashMap<EReference, IJvmTypeRefFinisher>();
+
+ /** The jvm links. */
+ private Set<EReference> jvmLinks = new HashSet<EReference>();
+
+ /**
+ * Instantiates a new lazy jvm type linking helper.
+ */
+ public LazyJvmTypeLinkingHelper() {
+ }
+
+ /**
+ * Registers a jvmTypeReference for a given semanticReference.
+ *
+ * @param semanticReference
+ * the semantic reference
+ * @param jvmTypeReference
+ * the jvm type reference
+ * @return the e reference
+ */
+ public EReference register(EReference semanticReference,
+ EReference jvmTypeReference) {
+ return register(semanticReference, jvmTypeReference, null, null);
+ }
+
+ /**
+ * Registers a jvmTypeReference for a given semanticReference.
+ *
+ * @param semanticReference
+ * the semantic reference
+ * @param jvmTypeReference
+ * the jvm type reference
+ * @param enhancer
+ * the enhancer
+ * @param finisher
+ * the finisher
+ * @return the e reference
+ */
+ public EReference register(EReference semanticReference,
+ EReference jvmTypeReference,
+ IJvmLinkCrossRefStringEnhancer enhancer,
+ IJvmTypeRefFinisher finisher) {
+
+ Set<EReference> links = linkMappings.get(semanticReference);
+ if (links == null) {
+ links = new HashSet<EReference>();
+ linkMappings.put(semanticReference, links);
+ }
+ links.add(jvmTypeReference);
+ jvmLinks.add(jvmTypeReference);
+
+ if (enhancer != null) {
+ jvmLinkToEnhancers.put(jvmTypeReference, enhancer);
+ }
+
+ if (finisher != null) {
+ jvmLinkToFinisher.put(jvmTypeReference, finisher);
+ }
+
+ return jvmTypeReference;
+ }
+
+ /**
+ * Returns true, if the semanticReference needs jvmLinking.
+ *
+ * @param semanticReference
+ * the semantic reference
+ * @return true, if successful
+ */
+ public boolean needsJvmLinking(EReference semanticReference) {
+ return linkMappings.containsKey(semanticReference);
+ }
+
+ /**
+ * Returns true, if the given reference is a jvmLink.
+ *
+ * @param feature
+ * the feature
+ * @return true, if is jvm link
+ */
+ public boolean isJvmLink(EStructuralFeature feature) {
+ if (feature instanceof EReference) {
+ return jvmLinks.contains(feature);
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * Returns the enhancer for the given feature.
+ *
+ * @param feature
+ * the feature
+ * @return the enhancer
+ */
+ public IJvmLinkCrossRefStringEnhancer getEnhancer(EStructuralFeature feature) {
+ return jvmLinkToEnhancers.get(feature);
+ }
+
+ /**
+ * Returns the finisher for the given feature.
+ *
+ * @param feature
+ * the feature
+ * @return the finisher
+ */
+ public IJvmTypeRefFinisher getFinisher(EStructuralFeature feature) {
+ return jvmLinkToFinisher.get(feature);
+ }
+
+ /**
+ * Returns the jvmLinkingReference for the given semanticReference.
+ *
+ * @param semanticReference
+ * the semantic reference
+ * @return the jvm linking references
+ */
+ public Set<EReference> getJvmLinkingReferences(EReference semanticReference) {
+ return linkMappings.get(semanticReference);
+ }
+
+ /**
+ * The JvmLinks are a helper construct to provide proper proxies. But in
+ * some cases the cross reference String that is used for scoping needs to
+ * be enhanced. For instance if a DTO mapper is queried. The naming
+ * convention defines, that a mapper is called "{DTO-FQN}Mapper". So the
+ * jvmLink-proxy from LDto#mapperJvmType needs to become resolved with the
+ * name of the mapper.
+ */
+ public interface IJvmLinkCrossRefStringEnhancer {
+
+ /**
+ * Returns the crossRefString to be used.
+ * <p>
+ * Example: given "ItemDTO" and returned "ItemDTOMapper".
+ *
+ * @param context
+ * the context
+ * @param feature
+ * the feature
+ * @param crossRefString
+ * the cross ref string
+ * @return the string
+ */
+ String enhance(EObject context, EStructuralFeature feature,
+ String crossRefString);
+
+ }
+
+ /**
+ * The JvmHelperProxies will be validated by Xbase. So it is necessary to
+ * add type arguments to raw types. This finisher gives access to the
+ * created {@link JvmTypeReference}.
+ */
+ public interface IJvmTypeRefFinisher {
+
+ /**
+ * Allows to manipulate the created type reference.
+ *
+ * @param jvmLinkFeature
+ * the jvm link feature
+ * @param typeRef
+ * the type ref
+ */
+ void finish(EStructuralFeature jvmLinkFeature, JvmTypeReference typeRef);
+
+ }
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXImportDeclaration.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXImportDeclaration.java
new file mode 100644
index 0000000..86a5dba
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXImportDeclaration.java
@@ -0,0 +1,89 @@
+/**
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.oxtype;
+
+import org.eclipse.xtext.xtype.XImportDeclaration;
+
+/**
+ * <!-- begin-user-doc --> A representation of the model object '<em><b>OX
+ * Import Declaration</b></em>'. <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration#isFqnImport
+ * <em>Fqn Import</em>}</li>
+ * <li>{@link org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration#getImportedFullyQualifiedName
+ * <em>Imported Fully Qualified Name</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage#getOXImportDeclaration()
+ * @model
+ * @generated
+ */
+public interface OXImportDeclaration extends XImportDeclaration {
+ /**
+ * Returns the value of the '<em><b>Fqn Import</b></em>' attribute. <!--
+ * begin-user-doc -->
+ * <p>
+ * If the meaning of the '<em>Fqn Import</em>' attribute isn't clear, there
+ * really should be more of a description here...
+ * </p>
+ * <!-- end-user-doc -->
+ *
+ * @return the value of the '<em>Fqn Import</em>' attribute.
+ * @see #setFqnImport(boolean)
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage#getOXImportDeclaration_FqnImport()
+ * @model
+ * @generated
+ */
+ boolean isFqnImport();
+
+ /**
+ * Sets the value of the
+ * '{@link org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration#isFqnImport
+ * <em>Fqn Import</em>}' attribute. <!-- begin-user-doc --> <!--
+ * end-user-doc -->
+ *
+ * @param value
+ * the new value of the '<em>Fqn Import</em>' attribute.
+ * @see #isFqnImport()
+ * @generated
+ */
+ void setFqnImport(boolean value);
+
+ /**
+ * Returns the value of the '<em><b>Imported Fully Qualified Name</b></em>'
+ * attribute. <!-- begin-user-doc -->
+ * <p>
+ * If the meaning of the '<em>Imported Fully Qualified Name</em>' attribute
+ * isn't clear, there really should be more of a description here...
+ * </p>
+ * <!-- end-user-doc -->
+ *
+ * @return the value of the '<em>Imported Fully Qualified Name</em>'
+ * attribute.
+ * @see #setImportedFullyQualifiedName(String)
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage#getOXImportDeclaration_ImportedFullyQualifiedName()
+ * @model
+ * @generated
+ */
+ String getImportedFullyQualifiedName();
+
+ /**
+ * Sets the value of the
+ * '{@link org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration#getImportedFullyQualifiedName
+ * <em>Imported Fully Qualified Name</em>}' attribute. <!-- begin-user-doc
+ * --> <!-- end-user-doc -->
+ *
+ * @param value
+ * the new value of the '<em>Imported Fully Qualified Name</em>'
+ * attribute.
+ * @see #getImportedFullyQualifiedName()
+ * @generated
+ */
+ void setImportedFullyQualifiedName(String value);
+
+} // OXImportDeclaration
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXtypeFactory.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXtypeFactory.java
new file mode 100644
index 0000000..673bf99
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXtypeFactory.java
@@ -0,0 +1,43 @@
+/**
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.oxtype;
+
+import org.eclipse.emf.ecore.EFactory;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Factory</b> for the model.
+ * It provides a create method for each non-abstract class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage
+ * @generated
+ */
+public interface OXtypeFactory extends EFactory {
+ /**
+ * The singleton instance of the factory.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ OXtypeFactory eINSTANCE = org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXtypeFactoryImpl.init();
+
+ /**
+ * Returns a new object of class '<em>OX Import Declaration</em>'.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @return a new object of class '<em>OX Import Declaration</em>'.
+ * @generated
+ */
+ OXImportDeclaration createOXImportDeclaration();
+
+ /**
+ * Returns the package supported by this factory.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @return the package supported by this factory.
+ * @generated
+ */
+ OXtypePackage getOXtypePackage();
+
+} //OXtypeFactory
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXtypePackage.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXtypePackage.java
new file mode 100644
index 0000000..399ae19
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXtypePackage.java
@@ -0,0 +1,234 @@
+/**
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.oxtype;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.xtext.xtype.XtypePackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Package</b> for the model.
+ * It contains accessors for the meta objects to represent
+ * <ul>
+ * <li>each class,</li>
+ * <li>each feature of each class,</li>
+ * <li>each enum,</li>
+ * <li>and each data type</li>
+ * </ul>
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXtypeFactory
+ * @model kind="package"
+ * @generated
+ */
+public interface OXtypePackage extends EPackage {
+ /**
+ * The package name.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ String eNAME = "oxtype";
+
+ /**
+ * The package namespace URI.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ String eNS_URI = "http://www.eclipse.org/osbp/xtext/oxtype/OXtype";
+
+ /**
+ * The package namespace name.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ String eNS_PREFIX = "oxtype";
+
+ /**
+ * The singleton instance of the package.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ OXtypePackage eINSTANCE = org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXtypePackageImpl.init();
+
+ /**
+ * The meta object id for the '{@link org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXImportDeclarationImpl <em>OX Import Declaration</em>}' class.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXImportDeclarationImpl
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXtypePackageImpl#getOXImportDeclaration()
+ * @generated
+ */
+ int OX_IMPORT_DECLARATION = 0;
+
+ /**
+ * The feature id for the '<em><b>Wildcard</b></em>' attribute.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ * @ordered
+ */
+ int OX_IMPORT_DECLARATION__WILDCARD = XtypePackage.XIMPORT_DECLARATION__WILDCARD;
+
+ /**
+ * The feature id for the '<em><b>Extension</b></em>' attribute.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ * @ordered
+ */
+ int OX_IMPORT_DECLARATION__EXTENSION = XtypePackage.XIMPORT_DECLARATION__EXTENSION;
+
+ /**
+ * The feature id for the '<em><b>Static</b></em>' attribute.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ * @ordered
+ */
+ int OX_IMPORT_DECLARATION__STATIC = XtypePackage.XIMPORT_DECLARATION__STATIC;
+
+ /**
+ * The feature id for the '<em><b>Imported Type</b></em>' reference.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ * @ordered
+ */
+ int OX_IMPORT_DECLARATION__IMPORTED_TYPE = XtypePackage.XIMPORT_DECLARATION__IMPORTED_TYPE;
+
+ /**
+ * The feature id for the '<em><b>Member Name</b></em>' attribute.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ * @ordered
+ */
+ int OX_IMPORT_DECLARATION__MEMBER_NAME = XtypePackage.XIMPORT_DECLARATION__MEMBER_NAME;
+
+ /**
+ * The feature id for the '<em><b>Imported Namespace</b></em>' attribute.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ * @ordered
+ */
+ int OX_IMPORT_DECLARATION__IMPORTED_NAMESPACE = XtypePackage.XIMPORT_DECLARATION__IMPORTED_NAMESPACE;
+
+ /**
+ * The feature id for the '<em><b>Fqn Import</b></em>' attribute.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ * @ordered
+ */
+ int OX_IMPORT_DECLARATION__FQN_IMPORT = XtypePackage.XIMPORT_DECLARATION_FEATURE_COUNT + 0;
+
+ /**
+ * The feature id for the '<em><b>Imported Fully Qualified Name</b></em>' attribute.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ * @ordered
+ */
+ int OX_IMPORT_DECLARATION__IMPORTED_FULLY_QUALIFIED_NAME = XtypePackage.XIMPORT_DECLARATION_FEATURE_COUNT + 1;
+
+ /**
+ * The number of structural features of the '<em>OX Import Declaration</em>' class.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ * @ordered
+ */
+ int OX_IMPORT_DECLARATION_FEATURE_COUNT = XtypePackage.XIMPORT_DECLARATION_FEATURE_COUNT + 2;
+
+
+ /**
+ * Returns the meta object for class '{@link org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration <em>OX Import Declaration</em>}'.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @return the meta object for class '<em>OX Import Declaration</em>'.
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration
+ * @generated
+ */
+ EClass getOXImportDeclaration();
+
+ /**
+ * Returns the meta object for the attribute '{@link org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration#isFqnImport <em>Fqn Import</em>}'.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @return the meta object for the attribute '<em>Fqn Import</em>'.
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration#isFqnImport()
+ * @see #getOXImportDeclaration()
+ * @generated
+ */
+ EAttribute getOXImportDeclaration_FqnImport();
+
+ /**
+ * Returns the meta object for the attribute '{@link org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration#getImportedFullyQualifiedName <em>Imported Fully Qualified Name</em>}'.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @return the meta object for the attribute '<em>Imported Fully Qualified Name</em>'.
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration#getImportedFullyQualifiedName()
+ * @see #getOXImportDeclaration()
+ * @generated
+ */
+ EAttribute getOXImportDeclaration_ImportedFullyQualifiedName();
+
+ /**
+ * Returns the factory that creates the instances of the model.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @return the factory that creates the instances of the model.
+ * @generated
+ */
+ OXtypeFactory getOXtypeFactory();
+
+ /**
+ * <!-- begin-user-doc -->
+ * Defines literals for the meta objects that represent
+ * <ul>
+ * <li>each class,</li>
+ * <li>each feature of each class,</li>
+ * <li>each enum,</li>
+ * <li>and each data type</li>
+ * </ul>
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ interface Literals {
+ /**
+ * The meta object literal for the '{@link org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXImportDeclarationImpl <em>OX Import Declaration</em>}' class.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXImportDeclarationImpl
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXtypePackageImpl#getOXImportDeclaration()
+ * @generated
+ */
+ EClass OX_IMPORT_DECLARATION = eINSTANCE.getOXImportDeclaration();
+
+ /**
+ * The meta object literal for the '<em><b>Fqn Import</b></em>' attribute feature.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ EAttribute OX_IMPORT_DECLARATION__FQN_IMPORT = eINSTANCE.getOXImportDeclaration_FqnImport();
+
+ /**
+ * The meta object literal for the '<em><b>Imported Fully Qualified Name</b></em>' attribute feature.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ EAttribute OX_IMPORT_DECLARATION__IMPORTED_FULLY_QUALIFIED_NAME = eINSTANCE.getOXImportDeclaration_ImportedFullyQualifiedName();
+
+ }
+
+} //OXtypePackage
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXImportDeclarationImpl.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXImportDeclarationImpl.java
new file mode 100644
index 0000000..359e116
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXImportDeclarationImpl.java
@@ -0,0 +1,225 @@
+/**
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.oxtype.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration;
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage;
+import org.eclipse.xtext.xtype.impl.XImportDeclarationImplCustom;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '<em><b>OX
+ * Import Declaration</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXImportDeclarationImpl#isFqnImport
+ * <em>Fqn Import</em>}</li>
+ * <li>{@link org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXImportDeclarationImpl#getImportedFullyQualifiedName
+ * <em>Imported Fully Qualified Name</em>}</li>
+ * </ul>
+ *
+ * ATTENTION:<br>
+ * Needs to extend XImportDeclarationImplCustom!
+ */
+@SuppressWarnings("restriction")
+public class OXImportDeclarationImpl extends XImportDeclarationImplCustom implements OXImportDeclaration {
+ /**
+ * The default value of the '{@link #isFqnImport() <em>Fqn Import</em>}'
+ * attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+ *
+ * @see #isFqnImport()
+ * @generated
+ * @ordered
+ */
+ protected static final boolean FQN_IMPORT_EDEFAULT = false;
+
+ /**
+ * The cached value of the '{@link #isFqnImport() <em>Fqn Import</em>}'
+ * attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+ *
+ * @see #isFqnImport()
+ * @generated
+ * @ordered
+ */
+ protected boolean fqnImport = FQN_IMPORT_EDEFAULT;
+
+ /**
+ * The default value of the '{@link #getImportedFullyQualifiedName()
+ * <em>Imported Fully Qualified Name</em>}' attribute. <!-- begin-user-doc
+ * --> <!-- end-user-doc -->
+ *
+ * @see #getImportedFullyQualifiedName()
+ * @generated
+ * @ordered
+ */
+ protected static final String IMPORTED_FULLY_QUALIFIED_NAME_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getImportedFullyQualifiedName()
+ * <em>Imported Fully Qualified Name</em>}' attribute. <!-- begin-user-doc
+ * --> <!-- end-user-doc -->
+ *
+ * @see #getImportedFullyQualifiedName()
+ * @generated
+ * @ordered
+ */
+ protected String importedFullyQualifiedName = IMPORTED_FULLY_QUALIFIED_NAME_EDEFAULT;
+
+ /**
+ * <!-- begin-user-doc --> <!-- end-user-doc -->
+ *
+ * @generated
+ */
+ protected OXImportDeclarationImpl() {
+ super();
+ }
+
+ /**
+ * <!-- begin-user-doc --> <!-- end-user-doc -->
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass() {
+ return OXtypePackage.Literals.OX_IMPORT_DECLARATION;
+ }
+
+ /**
+ * <!-- begin-user-doc --> <!-- end-user-doc -->
+ *
+ * @generated
+ */
+ public boolean isFqnImport() {
+ return fqnImport;
+ }
+
+ /**
+ * <!-- begin-user-doc --> <!-- end-user-doc -->
+ *
+ * @generated
+ */
+ public void setFqnImport(boolean newFqnImport) {
+ boolean oldFqnImport = fqnImport;
+ fqnImport = newFqnImport;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, OXtypePackage.OX_IMPORT_DECLARATION__FQN_IMPORT,
+ oldFqnImport, fqnImport));
+ }
+
+ /**
+ * <!-- begin-user-doc --> <!-- end-user-doc -->
+ *
+ * @generated
+ */
+ public String getImportedFullyQualifiedName() {
+ return importedFullyQualifiedName;
+ }
+
+ /**
+ * <!-- begin-user-doc --> <!-- end-user-doc -->
+ *
+ * @generated
+ */
+ public void setImportedFullyQualifiedName(String newImportedFullyQualifiedName) {
+ String oldImportedFullyQualifiedName = importedFullyQualifiedName;
+ importedFullyQualifiedName = newImportedFullyQualifiedName;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET,
+ OXtypePackage.OX_IMPORT_DECLARATION__IMPORTED_FULLY_QUALIFIED_NAME, oldImportedFullyQualifiedName,
+ importedFullyQualifiedName));
+ }
+
+ /**
+ * <!-- begin-user-doc --> <!-- end-user-doc -->
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType) {
+ switch (featureID) {
+ case OXtypePackage.OX_IMPORT_DECLARATION__FQN_IMPORT:
+ return isFqnImport();
+ case OXtypePackage.OX_IMPORT_DECLARATION__IMPORTED_FULLY_QUALIFIED_NAME:
+ return getImportedFullyQualifiedName();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ * <!-- begin-user-doc --> <!-- end-user-doc -->
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue) {
+ switch (featureID) {
+ case OXtypePackage.OX_IMPORT_DECLARATION__FQN_IMPORT:
+ setFqnImport((Boolean) newValue);
+ return;
+ case OXtypePackage.OX_IMPORT_DECLARATION__IMPORTED_FULLY_QUALIFIED_NAME:
+ setImportedFullyQualifiedName((String) newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ * <!-- begin-user-doc --> <!-- end-user-doc -->
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID) {
+ switch (featureID) {
+ case OXtypePackage.OX_IMPORT_DECLARATION__FQN_IMPORT:
+ setFqnImport(FQN_IMPORT_EDEFAULT);
+ return;
+ case OXtypePackage.OX_IMPORT_DECLARATION__IMPORTED_FULLY_QUALIFIED_NAME:
+ setImportedFullyQualifiedName(IMPORTED_FULLY_QUALIFIED_NAME_EDEFAULT);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ * <!-- begin-user-doc --> <!-- end-user-doc -->
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID) {
+ switch (featureID) {
+ case OXtypePackage.OX_IMPORT_DECLARATION__FQN_IMPORT:
+ return fqnImport != FQN_IMPORT_EDEFAULT;
+ case OXtypePackage.OX_IMPORT_DECLARATION__IMPORTED_FULLY_QUALIFIED_NAME:
+ return IMPORTED_FULLY_QUALIFIED_NAME_EDEFAULT == null ? importedFullyQualifiedName != null
+ : !IMPORTED_FULLY_QUALIFIED_NAME_EDEFAULT.equals(importedFullyQualifiedName);
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ * <!-- begin-user-doc --> <!-- end-user-doc -->
+ *
+ * @generated
+ */
+ @Override
+ public String toString() {
+ if (eIsProxy())
+ return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (fqnImport: ");
+ result.append(fqnImport);
+ result.append(", importedFullyQualifiedName: ");
+ result.append(importedFullyQualifiedName);
+ result.append(')');
+ return result.toString();
+ }
+
+} // OXImportDeclarationImpl
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXtypeFactoryImpl.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXtypeFactoryImpl.java
new file mode 100644
index 0000000..45d9c2d
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXtypeFactoryImpl.java
@@ -0,0 +1,96 @@
+/**
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.oxtype.impl;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.impl.EFactoryImpl;
+
+import org.eclipse.emf.ecore.plugin.EcorePlugin;
+
+import org.eclipse.osbp.xtext.oxtype.oxtype.*;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Factory</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class OXtypeFactoryImpl extends EFactoryImpl implements OXtypeFactory {
+ /**
+ * Creates the default factory implementation.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ public static OXtypeFactory init() {
+ try {
+ OXtypeFactory theOXtypeFactory = (OXtypeFactory)EPackage.Registry.INSTANCE.getEFactory(OXtypePackage.eNS_URI);
+ if (theOXtypeFactory != null) {
+ return theOXtypeFactory;
+ }
+ }
+ catch (Exception exception) {
+ EcorePlugin.INSTANCE.log(exception);
+ }
+ return new OXtypeFactoryImpl();
+ }
+
+ /**
+ * Creates an instance of the factory.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ public OXtypeFactoryImpl() {
+ super();
+ }
+
+ /**
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ @Override
+ public EObject create(EClass eClass) {
+ switch (eClass.getClassifierID()) {
+ case OXtypePackage.OX_IMPORT_DECLARATION: return createOXImportDeclaration();
+ default:
+ throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
+ }
+ }
+
+ /**
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ public OXImportDeclaration createOXImportDeclaration() {
+ OXImportDeclarationImpl oxImportDeclaration = new OXImportDeclarationImpl();
+ return oxImportDeclaration;
+ }
+
+ /**
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ public OXtypePackage getOXtypePackage() {
+ return (OXtypePackage)getEPackage();
+ }
+
+ /**
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @deprecated
+ * @generated
+ */
+ @Deprecated
+ public static OXtypePackage getPackage() {
+ return OXtypePackage.eINSTANCE;
+ }
+
+} //OXtypeFactoryImpl
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXtypePackageImpl.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXtypePackageImpl.java
new file mode 100644
index 0000000..72af35f
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXtypePackageImpl.java
@@ -0,0 +1,201 @@
+/**
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.oxtype.impl;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration;
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXtypeFactory;
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage;
+
+import org.eclipse.xtext.common.types.TypesPackage;
+
+import org.eclipse.xtext.xtype.XtypePackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Package</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class OXtypePackageImpl extends EPackageImpl implements OXtypePackage {
+ /**
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ private EClass oxImportDeclarationEClass = null;
+
+ /**
+ * Creates an instance of the model <b>Package</b>, registered with
+ * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
+ * package URI value.
+ * <p>Note: the correct way to create the package is via the static
+ * factory method {@link #init init()}, which also performs
+ * initialization of the package, or returns the registered package,
+ * if one already exists.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @see org.eclipse.emf.ecore.EPackage.Registry
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage#eNS_URI
+ * @see #init()
+ * @generated
+ */
+ private OXtypePackageImpl() {
+ super(eNS_URI, OXtypeFactory.eINSTANCE);
+ }
+
+ /**
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ private static boolean isInited = false;
+
+ /**
+ * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon which it depends.
+ *
+ * <p>This method is used to initialize {@link OXtypePackage#eINSTANCE} when that field is accessed.
+ * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @see #eNS_URI
+ * @see #createPackageContents()
+ * @see #initializePackageContents()
+ * @generated
+ */
+ public static OXtypePackage init() {
+ if (isInited) return (OXtypePackage)EPackage.Registry.INSTANCE.getEPackage(OXtypePackage.eNS_URI);
+
+ // Obtain or create and register package
+ OXtypePackageImpl theOXtypePackage = (OXtypePackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof OXtypePackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new OXtypePackageImpl());
+
+ isInited = true;
+
+ // Initialize simple dependencies
+ XtypePackage.eINSTANCE.eClass();
+ TypesPackage.eINSTANCE.eClass();
+
+ // Create package meta-data objects
+ theOXtypePackage.createPackageContents();
+
+ // Initialize created meta-data
+ theOXtypePackage.initializePackageContents();
+
+ // Mark meta-data to indicate it can't be changed
+ theOXtypePackage.freeze();
+
+
+ // Update the registry and return the package
+ EPackage.Registry.INSTANCE.put(OXtypePackage.eNS_URI, theOXtypePackage);
+ return theOXtypePackage;
+ }
+
+ /**
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ public EClass getOXImportDeclaration() {
+ return oxImportDeclarationEClass;
+ }
+
+ /**
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ public EAttribute getOXImportDeclaration_FqnImport() {
+ return (EAttribute)oxImportDeclarationEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ public EAttribute getOXImportDeclaration_ImportedFullyQualifiedName() {
+ return (EAttribute)oxImportDeclarationEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ public OXtypeFactory getOXtypeFactory() {
+ return (OXtypeFactory)getEFactoryInstance();
+ }
+
+ /**
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ private boolean isCreated = false;
+
+ /**
+ * Creates the meta-model objects for the package. This method is
+ * guarded to have no affect on any invocation but its first.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ public void createPackageContents() {
+ if (isCreated) return;
+ isCreated = true;
+
+ // Create classes and their features
+ oxImportDeclarationEClass = createEClass(OX_IMPORT_DECLARATION);
+ createEAttribute(oxImportDeclarationEClass, OX_IMPORT_DECLARATION__FQN_IMPORT);
+ createEAttribute(oxImportDeclarationEClass, OX_IMPORT_DECLARATION__IMPORTED_FULLY_QUALIFIED_NAME);
+ }
+
+ /**
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ private boolean isInitialized = false;
+
+ /**
+ * Complete the initialization of the package and its meta-model. This
+ * method is guarded to have no affect on any invocation but its first.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ public void initializePackageContents() {
+ if (isInitialized) return;
+ isInitialized = true;
+
+ // Initialize package
+ setName(eNAME);
+ setNsPrefix(eNS_PREFIX);
+ setNsURI(eNS_URI);
+
+ // Obtain other dependent packages
+ XtypePackage theXtypePackage = (XtypePackage)EPackage.Registry.INSTANCE.getEPackage(XtypePackage.eNS_URI);
+
+ // Create type parameters
+
+ // Set bounds for type parameters
+
+ // Add supertypes to classes
+ oxImportDeclarationEClass.getESuperTypes().add(theXtypePackage.getXImportDeclaration());
+
+ // Initialize classes and features; add operations and parameters
+ initEClass(oxImportDeclarationEClass, OXImportDeclaration.class, "OXImportDeclaration", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getOXImportDeclaration_FqnImport(), ecorePackage.getEBoolean(), "fqnImport", null, 0, 1, OXImportDeclaration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getOXImportDeclaration_ImportedFullyQualifiedName(), ecorePackage.getEString(), "importedFullyQualifiedName", null, 0, 1, OXImportDeclaration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ // Create resource
+ createResource(eNS_URI);
+ }
+
+} //OXtypePackageImpl
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/util/OXtypeAdapterFactory.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/util/OXtypeAdapterFactory.java
new file mode 100644
index 0000000..0db98dc
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/util/OXtypeAdapterFactory.java
@@ -0,0 +1,141 @@
+/**
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.oxtype.util;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+
+import org.eclipse.emf.ecore.EObject;
+
+import org.eclipse.osbp.xtext.oxtype.oxtype.*;
+
+import org.eclipse.xtext.xtype.XImportDeclaration;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Adapter Factory</b> for the model.
+ * It provides an adapter <code>createXXX</code> method for each class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage
+ * @generated
+ */
+public class OXtypeAdapterFactory extends AdapterFactoryImpl {
+ /**
+ * The cached model package.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ protected static OXtypePackage modelPackage;
+
+ /**
+ * Creates an instance of the adapter factory.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ public OXtypeAdapterFactory() {
+ if (modelPackage == null) {
+ modelPackage = OXtypePackage.eINSTANCE;
+ }
+ }
+
+ /**
+ * Returns whether this factory is applicable for the type of the object.
+ * <!-- begin-user-doc -->
+ * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
+ * <!-- end-user-doc -->
+ * @return whether this factory is applicable for the type of the object.
+ * @generated
+ */
+ @Override
+ public boolean isFactoryForType(Object object) {
+ if (object == modelPackage) {
+ return true;
+ }
+ if (object instanceof EObject) {
+ return ((EObject)object).eClass().getEPackage() == modelPackage;
+ }
+ return false;
+ }
+
+ /**
+ * The switch that delegates to the <code>createXXX</code> methods.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ protected OXtypeSwitch<Adapter> modelSwitch =
+ new OXtypeSwitch<Adapter>() {
+ @Override
+ public Adapter caseOXImportDeclaration(OXImportDeclaration object) {
+ return createOXImportDeclarationAdapter();
+ }
+ @Override
+ public Adapter caseXImportDeclaration(XImportDeclaration object) {
+ return createXImportDeclarationAdapter();
+ }
+ @Override
+ public Adapter defaultCase(EObject object) {
+ return createEObjectAdapter();
+ }
+ };
+
+ /**
+ * Creates an adapter for the <code>target</code>.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @param target the object to adapt.
+ * @return the adapter for the <code>target</code>.
+ * @generated
+ */
+ @Override
+ public Adapter createAdapter(Notifier target) {
+ return modelSwitch.doSwitch((EObject)target);
+ }
+
+
+ /**
+ * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration <em>OX Import Declaration</em>}'.
+ * <!-- begin-user-doc -->
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ * <!-- end-user-doc -->
+ * @return the new adapter.
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration
+ * @generated
+ */
+ public Adapter createOXImportDeclarationAdapter() {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link org.eclipse.xtext.xtype.XImportDeclaration <em>XImport Declaration</em>}'.
+ * <!-- begin-user-doc -->
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ * <!-- end-user-doc -->
+ * @return the new adapter.
+ * @see org.eclipse.xtext.xtype.XImportDeclaration
+ * @generated
+ */
+ public Adapter createXImportDeclarationAdapter() {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for the default case.
+ * <!-- begin-user-doc -->
+ * This default implementation returns null.
+ * <!-- end-user-doc -->
+ * @return the new adapter.
+ * @generated
+ */
+ public Adapter createEObjectAdapter() {
+ return null;
+ }
+
+} //OXtypeAdapterFactory
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/util/OXtypeSwitch.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/util/OXtypeSwitch.java
new file mode 100644
index 0000000..41ef37d
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/util/OXtypeSwitch.java
@@ -0,0 +1,129 @@
+/**
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.oxtype.util;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.util.Switch;
+
+import org.eclipse.osbp.xtext.oxtype.oxtype.*;
+
+import org.eclipse.xtext.xtype.XImportDeclaration;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Switch</b> for the model's inheritance hierarchy.
+ * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the <code>caseXXX</code> method for each class of the model,
+ * starting with the actual class of the object
+ * and proceeding up the inheritance hierarchy
+ * until a non-null result is returned,
+ * which is the result of the switch.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage
+ * @generated
+ */
+public class OXtypeSwitch<T> extends Switch<T> {
+ /**
+ * The cached model package
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ protected static OXtypePackage modelPackage;
+
+ /**
+ * Creates an instance of the switch.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+ public OXtypeSwitch() {
+ if (modelPackage == null) {
+ modelPackage = OXtypePackage.eINSTANCE;
+ }
+ }
+
+ /**
+ * Checks whether this is a switch for the given package.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @param ePackage the package in question.
+ * @return whether this is a switch for the given package.
+ * @generated
+ */
+ @Override
+ protected boolean isSwitchFor(EPackage ePackage) {
+ return ePackage == modelPackage;
+ }
+
+ /**
+ * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @return the first non-null result returned by a <code>caseXXX</code> call.
+ * @generated
+ */
+ @Override
+ protected T doSwitch(int classifierID, EObject theEObject) {
+ switch (classifierID) {
+ case OXtypePackage.OX_IMPORT_DECLARATION: {
+ OXImportDeclaration oxImportDeclaration = (OXImportDeclaration)theEObject;
+ T result = caseOXImportDeclaration(oxImportDeclaration);
+ if (result == null) result = caseXImportDeclaration(oxImportDeclaration);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ default: return defaultCase(theEObject);
+ }
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of '<em>OX Import Declaration</em>'.
+ * <!-- begin-user-doc -->
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ * <!-- end-user-doc -->
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of '<em>OX Import Declaration</em>'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseOXImportDeclaration(OXImportDeclaration object) {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of '<em>XImport Declaration</em>'.
+ * <!-- begin-user-doc -->
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ * <!-- end-user-doc -->
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of '<em>XImport Declaration</em>'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseXImportDeclaration(XImportDeclaration object) {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
+ * <!-- begin-user-doc -->
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch, but this is the last case anyway.
+ * <!-- end-user-doc -->
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+ * @generated
+ */
+ @Override
+ public T defaultCase(EObject object) {
+ return null;
+ }
+
+} //OXtypeSwitch
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/scoping/OXImportSectionNamespaceScopeProvider.xtend b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/scoping/OXImportSectionNamespaceScopeProvider.xtend
new file mode 100644
index 0000000..591303a
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/scoping/OXImportSectionNamespaceScopeProvider.xtend
@@ -0,0 +1,32 @@
+package org.eclipse.osbp.xtext.oxtype.scoping
+
+import com.google.common.collect.Lists
+import java.util.List
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration
+import org.eclipse.xtext.scoping.impl.ImportNormalizer
+import org.eclipse.xtext.xtype.XImportDeclaration
+import org.eclipse.xtext.xtype.XImportSection
+import org.eclipse.xtext.xbase.scoping.XImportSectionNamespaceScopeProvider
+
+@SuppressWarnings("restriction")
+class OXImportSectionNamespaceScopeProvider extends XImportSectionNamespaceScopeProvider{
+
+ override List<ImportNormalizer> getImportedNamespaceResolvers(XImportSection importSection, boolean ignoreCase) {
+ val List<XImportDeclaration> importDeclarations = importSection.getImportDeclarations();
+ val List<ImportNormalizer> result = Lists.newArrayListWithExpectedSize(importDeclarations.size());
+ for (XImportDeclaration imp : importDeclarations) {
+ if (!imp.isStatic()) {
+ val OXImportDeclaration decl = imp as OXImportDeclaration;
+ var String value = decl.getImportedFullyQualifiedName();
+ if (value === null)
+ value = imp.getImportedNamespace();
+ if (value === null)
+ value = imp.getImportedTypeName();
+ val ImportNormalizer resolver = createImportedNamespaceResolver(value, ignoreCase);
+ if (resolver !== null)
+ result.add(resolver);
+ }
+ }
+ return result;
+ }
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/scoping/OXtypeScopeProvider.xtend b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/scoping/OXtypeScopeProvider.xtend
new file mode 100644
index 0000000..d1ed2f3
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/scoping/OXtypeScopeProvider.xtend
@@ -0,0 +1,15 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.scoping
+
+
+/**
+ * This class contains custom scoping description.
+ *
+ * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#scoping
+ * on how and when to use it.
+ */
+class OXtypeScopeProvider extends AbstractOXtypeScopeProvider {
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/validation/OXtypeJavaValidator.xtend b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/validation/OXtypeJavaValidator.xtend
new file mode 100644
index 0000000..c34f794
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/validation/OXtypeJavaValidator.xtend
@@ -0,0 +1,25 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.validation
+
+
+/**
+ * This class contains custom validation rules.
+ *
+ * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation
+ */
+class OXtypeJavaValidator extends AbstractOXtypeValidator {
+
+// public static val INVALID_NAME = 'invalidName'
+//
+// @Check
+// def checkGreetingStartsWithCapital(Greeting greeting) {
+// if (!Character.isUpperCase(greeting.name.charAt(0))) {
+// warning('Name should start with a capital',
+// OXtypePackage.Literals.GREETING__NAME,
+// INVALID_NAME)
+// }
+// }
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/validation/OXtypeValidator.xtend b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/validation/OXtypeValidator.xtend
new file mode 100644
index 0000000..7c89104
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/validation/OXtypeValidator.xtend
@@ -0,0 +1,25 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.validation
+
+
+/**
+ * This class contains custom validation rules.
+ *
+ * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation
+ */
+class OXtypeValidator extends AbstractOXtypeValidator {
+
+// public static val INVALID_NAME = 'invalidName'
+//
+// @Check
+// def checkGreetingStartsWithCapital(Greeting greeting) {
+// if (!Character.isUpperCase(greeting.name.charAt(0))) {
+// warning('Name should start with a capital',
+// OXtypePackage.Literals.GREETING__NAME,
+// INVALID_NAME)
+// }
+// }
+
+}
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..eec4da2
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,112 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+#=======================================================================
+# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany).
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+# Loetz GmbH&Co.KG - initial API and implementation
+#=======================================================================
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.eclipse.osbp.releng.maven</groupId>
+ <artifactId>org.eclipse.osbp.releng.maven.parent.tycho</artifactId>
+ <version>0.9.0-SNAPSHOT</version>
+ <relativePath/>
+ </parent>
+
+ <groupId>org.eclipse.osbp.xtext.oxtype</groupId>
+ <artifactId>org.eclipse.osbp.xtext.oxtype.aggregator</artifactId>
+ <packaging>pom</packaging>
+
+ <url>${osbp.site.repository.url}</url>
+ <scm>
+ <url>${osbp.scm.url}</url>
+ <connection>${osbp.scm.connection}</connection>
+ <developerConnection>${osbp.scm.connection.dev}</developerConnection>
+ <tag>HEAD</tag>
+ </scm>
+ <distributionManagement>
+ <site>
+ <id>gh-pages</id>
+ <name>OSBP GitHub Pages</name>
+ <url>${distribution.site.url}</url>
+ </site>
+ </distributionManagement>
+
+ <properties>
+
+ <osbp.gitrepo.name>${project.groupId}</osbp.gitrepo.name>
+ <xtextVersion>2.7.3</xtextVersion>
+ </properties>
+
+ <modules>
+ <module>org.eclipse.osbp.xtext.oxtype</module>
+ <module>org.eclipse.osbp.xtext.oxtype.ide</module>
+ <module>org.eclipse.osbp.xtext.oxtype.tests</module>
+ <module>org.eclipse.osbp.xtext.oxtype.ui</module>
+ <module>org.eclipse.osbp.xtext.oxtype.ui.tests</module>
+ <module>org.eclipse.osbp.xtext.oxtype.feature</module>
+ </modules>
+
+ <build>
+ <pluginManagement>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-javadoc-plugin</artifactId>
+ <configuration>
+ <skip>true</skip>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.eclipse.tycho</groupId>
+ <artifactId>target-platform-configuration</artifactId>
+ <version>${tycho-version}</version>
+ <configuration>
+ <filters>
+ <filter>
+ <type>eclipse-plugin</type>
+ <id>org.apache.aries.transaction.manager</id>
+ <restrictTo>
+ <!-- use a range that does not exist, we can not mix removeall and versionRange -->
+ <versionRange>[0.5.0,0.5.1)</versionRange>
+ </restrictTo>
+ </filter>
+ </filters>
+ <resolver>p2</resolver>
+ <pomDependencies>consider</pomDependencies>
+ <environments>
+ <environment>
+ <os>win32</os>
+ <ws>win32</ws>
+ <arch>x86_64</arch>
+ </environment>
+ <environment>
+ <os>linux</os>
+ <ws>gtk</ws>
+ <arch>x86</arch>
+ </environment>
+ <environment>
+ <os>linux</os>
+ <ws>gtk</ws>
+ <arch>x86_64</arch>
+ </environment>
+ <environment>
+ <os>macosx</os>
+ <ws>cocoa</ws>
+ <arch>x86_64</arch>
+ </environment>
+ </environments>
+ </configuration>
+ </plugin>
+ </plugins>
+ </pluginManagement>
+ </build>
+</project>