diff options
Diffstat (limited to 'org.eclipse.osbp.xtext.strategy.ui')
48 files changed, 28533 insertions, 0 deletions
diff --git a/org.eclipse.osbp.xtext.strategy.ui/.project b/org.eclipse.osbp.xtext.strategy.ui/.project new file mode 100644 index 0000000..361f84b --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/.project @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="UTF-8"?> +<projectDescription> + <name>org.eclipse.osbp.xtext.strategy.ui</name> + <comment></comment> + <projects> + </projects> + <buildSpec> + <buildCommand> + <name>org.eclipse.jdt.core.javabuilder</name> + <arguments> + </arguments> + </buildCommand> + <buildCommand> + <name>org.eclipse.pde.ManifestBuilder</name> + <arguments> + </arguments> + </buildCommand> + <buildCommand> + <name>org.eclipse.pde.SchemaBuilder</name> + <arguments> + </arguments> + </buildCommand> + <buildCommand> + <name>org.eclipse.xtext.ui.shared.xtextBuilder</name> + <arguments> + </arguments> + </buildCommand> + <buildCommand> + <name>org.eclipse.babel.editor.rbeBuilder</name> + <arguments> + </arguments> + </buildCommand> + <buildCommand> + <name>org.eclipse.m2e.core.maven2Builder</name> + <arguments> + </arguments> + </buildCommand> + </buildSpec> + <natures> + <nature>org.eclipse.m2e.core.maven2Nature</nature> + <nature>org.eclipse.jdt.core.javanature</nature> + <nature>org.eclipse.pde.PluginNature</nature> + <nature>org.eclipse.xtext.ui.shared.xtextNature</nature> + <nature>org.eclipse.babel.editor.rbeNature</nature> + </natures> +</projectDescription> diff --git a/org.eclipse.osbp.xtext.strategy.ui/LICENSE.txt b/org.eclipse.osbp.xtext.strategy.ui/LICENSE.txt new file mode 100644 index 0000000..ff42ad4 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/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.strategy.ui/META-INF/MANIFEST.MF b/org.eclipse.osbp.xtext.strategy.ui/META-INF/MANIFEST.MF new file mode 100644 index 0000000..2ffa92a --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/META-INF/MANIFEST.MF @@ -0,0 +1,34 @@ +Manifest-Version: 1.0 +Bundle-ManifestVersion: 2 +Bundle-Name: org.eclipse.osbp.xtext.strategy.ui +Bundle-Vendor: Eclipse OSBP +Bundle-Version: 0.9.0.qualifier +Bundle-SymbolicName: org.eclipse.osbp.xtext.strategy.ui;singleton:=true +Bundle-ActivationPolicy: lazy +Require-Bundle: org.slf4j.api;bundle-version="1.7.2", + javax.annotation;bundle-version="[1.1.0,1.2.0)", + com.google.inject;bundle-version="3.0.0", + org.eclipse.xtext.ui;bundle-version="[2.7.3,2.8.0)", + org.eclipse.ui.editors;bundle-version="3.5.0", + org.eclipse.ui.ide;bundle-version="3.5.0", + org.eclipse.xtext.ui.shared;bundle-version="[2.7.3,2.8.0)", + org.eclipse.ui, + org.eclipse.xtext.builder;bundle-version="[2.7.3,2.8.0)", + org.eclipse.xtext.xbase.lib;bundle-version="[2.7.3,2.8.0)", + org.antlr.runtime, + org.eclipse.xtext.common.types.ui;bundle-version="[2.7.3,2.8.0)", + org.eclipse.xtext.ui.codetemplates.ui;bundle-version="[2.7.3,2.8.0)", + org.eclipse.compare, + org.eclipse.osbp.dsl.common.xtext;bundle-version="[0.9.0,0.10.0)", + org.eclipse.osbp.xtext.basic.ui;bundle-version="[0.9.0,0.10.0)", + org.eclipse.xtext.xbase.ui;bundle-version="[2.7.3,2.8.0)", + org.eclipse.jdt.debug.ui, + org.eclipse.osbp.xtext.strategy;bundle-version="[0.9.0,0.10.0)" +Import-Package: org.apache.log4j, + org.eclipse.osbp.utils.constants;version="0.9.0" +Bundle-RequiredExecutionEnvironment: JavaSE-1.8 +Export-Package: org.eclipse.osbp.xtext.strategy.ui.quickfix;version="0.9.0", + org.eclipse.osbp.xtext.strategy.ui.contentassist;version="0.9.0", + org.eclipse.osbp.xtext.strategy.ui.contentassist.antlr;version="0.9.0", + org.eclipse.osbp.xtext.strategy.ui.internal;version="0.9.0" +Bundle-Activator: org.eclipse.osbp.xtext.strategy.ui.internal.StrategyDSLActivator diff --git a/org.eclipse.osbp.xtext.strategy.ui/about.html b/org.eclipse.osbp.xtext.strategy.ui/about.html new file mode 100644 index 0000000..64c0598 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/about.html @@ -0,0 +1,28 @@ +<!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>About</title> +</head> +<body lang="EN-US"> +<h2>About This Content</h2> + +<p>June 1, 2016</p> +<h3>License</h3> + +<p>The Eclipse Foundation makes available all content in this plug-in ("Content"). Unless otherwise +indicated below, the Content is provided to you under the terms and conditions of the +Eclipse Public License Version 1.0 ("EPL"). A copy of the EPL is 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>If you did not receive this Content directly from the Eclipse Foundation, the Content is +being redistributed by another party ("Redistributor") and different terms and conditions may +apply to your use of any object code in the Content. Check the Redistributor's license that was +provided with the Content. If no such license exists, contact the Redistributor. Unless otherwise +indicated below, the terms and conditions of the EPL still apply to any source code in the Content +and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p> + +</body> +</html>
\ No newline at end of file diff --git a/org.eclipse.osbp.xtext.strategy.ui/about.ini b/org.eclipse.osbp.xtext.strategy.ui/about.ini new file mode 100644 index 0000000..7df671f --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/about.ini @@ -0,0 +1,17 @@ +# about.ini +# contains information about a feature +# java.io.Properties file (ISO 8859-1 with "\" escapes) +# "%key" are externalized strings defined in about.properties +# This file does not need to be translated. + +# Property "aboutText" contains blurb for "About" dialog (translated) +aboutText=%featureText + +# Property "featureImage" contains path to feature image (32x32) +featureImage= + +# Property "appName" contains name of the application (translated) +appName=%featureName + +# Property "welcomePage" contains path to welcome page (special XML-based format) +welcomePage= diff --git a/org.eclipse.osbp.xtext.strategy.ui/about.mappings b/org.eclipse.osbp.xtext.strategy.ui/about.mappings new file mode 100644 index 0000000..4511a0a --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/about.mappings @@ -0,0 +1,6 @@ +# about.mappings +# contains fill-ins for about.properties +# java.io.Properties file (ISO 8859-1 with "\" escapes) +# This file does not need to be translated. + +0=qualifier diff --git a/org.eclipse.osbp.xtext.strategy.ui/about.properties b/org.eclipse.osbp.xtext.strategy.ui/about.properties new file mode 100644 index 0000000..f110c41 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/about.properties @@ -0,0 +1,26 @@ +# +# Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg) +# 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: +# Christophe Loetz (Loetz GmbH&Co.KG) - initial API and implementation +# + +# NLS_MESSAGEFORMAT_VAR + +featureName=org.eclipse.osbp.xtext.strategy.ui + +################ blurb property #################################### +featureText=\ +Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \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\ + Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation\n +################ end of blurb property #################################### diff --git a/org.eclipse.osbp.xtext.strategy.ui/build.properties b/org.eclipse.osbp.xtext.strategy.ui/build.properties new file mode 100644 index 0000000..1d49248 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/build.properties @@ -0,0 +1,17 @@ +source.. = src/,\ + src-gen/,\ + xtend-gen/ +bin.includes = about.properties, about.mappings, about.ini, about.html, META-INF/,\ + .,\ + .settings/,\ + plugin.xml,\ + i18n/,\ + license.html,\ + LICENSE.txt,\ + epl-v10.html,\ + icons/ +src.includes = about.properties, about.mappings, about.ini, about.html, license.html,\ + LICENSE.txt,\ + epl-v10.html,\ + icons/ + diff --git a/org.eclipse.osbp.xtext.strategy.ui/epl-v10.html b/org.eclipse.osbp.xtext.strategy.ui/epl-v10.html new file mode 100644 index 0000000..b398acc --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/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.strategy.ui/i18n/I18N.properties b/org.eclipse.osbp.xtext.strategy.ui/i18n/I18N.properties new file mode 100644 index 0000000..8ac129d --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/i18n/I18N.properties @@ -0,0 +1,66 @@ +# +#Mon Mar 13 16:32:11 CET 2017 +org.eclipse.osbp.xtext.strategy.FocusingEnhancer= +org.eclipse.osbp.xtext.strategy.FocusingEnhancer.focusingEnhancer= +org.eclipse.osbp.xtext.strategy.FocusingEnum= +org.eclipse.osbp.xtext.strategy.FocusingEnum.Backward= +org.eclipse.osbp.xtext.strategy.FocusingEnum.Forward= +org.eclipse.osbp.xtext.strategy.FocusingStrategy= +org.eclipse.osbp.xtext.strategy.FocusingStrategy.ecviewFocusingId\== +org.eclipse.osbp.xtext.strategy.FocusingStrategy.focus\== +org.eclipse.osbp.xtext.strategy.FocusingStrategy.focusingStrategy= +org.eclipse.osbp.xtext.strategy.FocusingStrategy.keyCode\== +org.eclipse.osbp.xtext.strategy.FocusingStrategy.keyStrokeDefinition= +org.eclipse.osbp.xtext.strategy.FocusingStrategy.modifierKeys= +org.eclipse.osbp.xtext.strategy.LayoutingEnum= +org.eclipse.osbp.xtext.strategy.LayoutingEnum.Css= +org.eclipse.osbp.xtext.strategy.LayoutingEnum.Form2= +org.eclipse.osbp.xtext.strategy.LayoutingEnum.Form3= +org.eclipse.osbp.xtext.strategy.LayoutingEnum.Grid= +org.eclipse.osbp.xtext.strategy.LayoutingEnum.Horizontal= +org.eclipse.osbp.xtext.strategy.LayoutingEnum.Vertical= +org.eclipse.osbp.xtext.strategy.LayoutingStrategy= +org.eclipse.osbp.xtext.strategy.LayoutingStrategy.layout\== +org.eclipse.osbp.xtext.strategy.LayoutingStrategy.layoutingStrategy= +org.eclipse.osbp.xtext.strategy.OSDefault= +org.eclipse.osbp.xtext.strategy.OSDefault.default= +org.eclipse.osbp.xtext.strategy.OSDefault.defaultFocusing\== +org.eclipse.osbp.xtext.strategy.OSDefault.defaultLayouting\== +org.eclipse.osbp.xtext.strategy.OSFocusingEnhancer= +org.eclipse.osbp.xtext.strategy.OSFocusingEnhancer.focusingEnhancer= +org.eclipse.osbp.xtext.strategy.OSFocusingStrategy= +org.eclipse.osbp.xtext.strategy.OSFocusingStrategy.ecviewFocusingId\== +org.eclipse.osbp.xtext.strategy.OSFocusingStrategy.focus\== +org.eclipse.osbp.xtext.strategy.OSFocusingStrategy.focusingStrategy= +org.eclipse.osbp.xtext.strategy.OSFocusingStrategy.keyCode\== +org.eclipse.osbp.xtext.strategy.OSFocusingStrategy.keyStrokeDefinition= +org.eclipse.osbp.xtext.strategy.OSFocusingStrategy.modifierKeys= +org.eclipse.osbp.xtext.strategy.OSLayoutingStrategy= +org.eclipse.osbp.xtext.strategy.OSLayoutingStrategy.layout\== +org.eclipse.osbp.xtext.strategy.OSLayoutingStrategy.layoutingStrategy= +org.eclipse.osbp.xtext.strategy.OSStrategies= +org.eclipse.osbp.xtext.strategy.OSStrategies.strategies= +org.eclipse.osbp.xtext.strategy.OSStrategy= +org.eclipse.osbp.xtext.strategy.OSStrategy.strategy= +org.eclipse.osbp.xtext.strategy.OSStrategyImport= +org.eclipse.osbp.xtext.strategy.OSStrategyImport.import= +org.eclipse.osbp.xtext.strategy.OSStrategyModel= +org.eclipse.osbp.xtext.strategy.OSStrategyPackage= +org.eclipse.osbp.xtext.strategy.OSStrategyPackage.package= +org.eclipse.osbp.xtext.strategy.OSStrategyQualifiedNameWithWildCard= +org.eclipse.osbp.xtext.strategy.Strategies= +org.eclipse.osbp.xtext.strategy.Strategies.strategies= +org.eclipse.osbp.xtext.strategy.Strategy= +org.eclipse.osbp.xtext.strategy.Strategy.strategy= +org.eclipse.osbp.xtext.strategy.StrategyDefault= +org.eclipse.osbp.xtext.strategy.StrategyDefault.default= +org.eclipse.osbp.xtext.strategy.StrategyDefault.defaultFocusing\== +org.eclipse.osbp.xtext.strategy.StrategyDefault.defaultLayouting\== +org.eclipse.osbp.xtext.strategy.StrategyImport= +org.eclipse.osbp.xtext.strategy.StrategyImport.import= +org.eclipse.osbp.xtext.strategy.StrategyModel= +org.eclipse.osbp.xtext.strategy.StrategyPackage= +org.eclipse.osbp.xtext.strategy.StrategyPackage.package= +org.eclipse.osbp.xtext.strategy.StrategyQualifiedNameWithWildCard= +org.eclipse.osbp.xtext.strategy.StrategyTarget= +org.eclipse.osbp.xtext.strategy.StrategyTarget.targets= diff --git a/org.eclipse.osbp.xtext.strategy.ui/icons/dsl_import.png b/org.eclipse.osbp.xtext.strategy.ui/icons/dsl_import.png Binary files differnew file mode 100644 index 0000000..f4fdcc9 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/icons/dsl_import.png diff --git a/org.eclipse.osbp.xtext.strategy.ui/icons/dsl_strategy.png b/org.eclipse.osbp.xtext.strategy.ui/icons/dsl_strategy.png Binary files differnew file mode 100644 index 0000000..e51db14 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/icons/dsl_strategy.png diff --git a/org.eclipse.osbp.xtext.strategy.ui/icons/focus-enhance.png b/org.eclipse.osbp.xtext.strategy.ui/icons/focus-enhance.png Binary files differnew file mode 100644 index 0000000..65cf8c0 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/icons/focus-enhance.png diff --git a/org.eclipse.osbp.xtext.strategy.ui/icons/focus.png b/org.eclipse.osbp.xtext.strategy.ui/icons/focus.png Binary files differnew file mode 100644 index 0000000..7f783b1 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/icons/focus.png diff --git a/org.eclipse.osbp.xtext.strategy.ui/icons/layout.png b/org.eclipse.osbp.xtext.strategy.ui/icons/layout.png Binary files differnew file mode 100644 index 0000000..0fead78 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/icons/layout.png diff --git a/org.eclipse.osbp.xtext.strategy.ui/icons/model.png b/org.eclipse.osbp.xtext.strategy.ui/icons/model.png Binary files differnew file mode 100644 index 0000000..cffb857 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/icons/model.png diff --git a/org.eclipse.osbp.xtext.strategy.ui/icons/package.gif b/org.eclipse.osbp.xtext.strategy.ui/icons/package.gif Binary files differnew file mode 100644 index 0000000..34506fb --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/icons/package.gif diff --git a/org.eclipse.osbp.xtext.strategy.ui/icons/strategies.png b/org.eclipse.osbp.xtext.strategy.ui/icons/strategies.png Binary files differnew file mode 100644 index 0000000..965cb00 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/icons/strategies.png diff --git a/org.eclipse.osbp.xtext.strategy.ui/icons/strategy-default.png b/org.eclipse.osbp.xtext.strategy.ui/icons/strategy-default.png Binary files differnew file mode 100644 index 0000000..38d4a25 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/icons/strategy-default.png diff --git a/org.eclipse.osbp.xtext.strategy.ui/license.html b/org.eclipse.osbp.xtext.strategy.ui/license.html new file mode 100644 index 0000000..6e579a5 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/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.strategy.ui/plugin.xml b/org.eclipse.osbp.xtext.strategy.ui/plugin.xml new file mode 100644 index 0000000..dfe12bd --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/plugin.xml @@ -0,0 +1,406 @@ +<?xml version="1.0" encoding="UTF-8"?> +<?eclipse version="3.0"?> + +<plugin> + + <extension + point="org.eclipse.ui.editors"> + <editor + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.XtextEditor" + contributorClass="org.eclipse.ui.editors.text.TextEditorActionContributor" + default="true" + extensions="strategy" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL" + icon="icons/dsl_strategy.png" + name="OSBP StrategyDSL Editor"> + </editor> + </extension> + <extension + point="org.eclipse.ui.handlers"> + <handler + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclarationHandler" + commandId="org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclaration"> + <activeWhen> + <reference + definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.Editor.opened"> + </reference> + </activeWhen> + </handler> + <handler + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.handler.ValidateActionHandler" + commandId="org.eclipse.osbp.xtext.strategy.StrategyDSL.validate"> + <activeWhen> + <reference + definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.Editor.opened"> + </reference> + </activeWhen> + </handler> + <!-- copy qualified name --> + <handler + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedNameHandler" + commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName"> + <activeWhen> + <reference definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.Editor.opened" /> + </activeWhen> + </handler> + <handler + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedNameHandler" + commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedName"> + <activeWhen> + <and> + <reference definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.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.strategy.StrategyDSL.Editor.opened"> + <and> + <reference definitionId="isActiveEditorAnInstanceOfXtextEditor"/> + <with variable="activeEditor"> + <test property="org.eclipse.xtext.ui.editor.XtextEditor.languageName" + value="org.eclipse.osbp.xtext.strategy.StrategyDSL" + forcePluginActivation="true"/> + </with> + </and> + </definition> + <definition id="org.eclipse.osbp.xtext.strategy.StrategyDSL.XtextEditor.opened"> + <and> + <reference definitionId="isXtextEditorActive"/> + <with variable="activeEditor"> + <test property="org.eclipse.xtext.ui.editor.XtextEditor.languageName" + value="org.eclipse.osbp.xtext.strategy.StrategyDSL" + forcePluginActivation="true"/> + </with> + </and> + </definition> + </extension> + <extension + point="org.eclipse.ui.preferencePages"> + <page + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.preferences.LanguageRootPreferencePage" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL" + icon="icons/dsl_strategy.png" + name="OSBP StrategyDSL"> + <keywordReference id="org.eclipse.osbp.xtext.strategy.ui.keyword_StrategyDSL"/> + </page> + <page + category="org.eclipse.osbp.xtext.strategy.StrategyDSL" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.syntaxcoloring.SyntaxColoringPreferencePage" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.coloring" + icon="icons/dsl_strategy.png" + name="Syntax Coloring"> + <keywordReference id="org.eclipse.osbp.xtext.strategy.ui.keyword_StrategyDSL"/> + </page> + <page + category="org.eclipse.osbp.xtext.strategy.StrategyDSL" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.templates.XtextTemplatePreferencePage" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.templates" + icon="icons/dsl_strategy.png" + name="Templates"> + <keywordReference id="org.eclipse.osbp.xtext.strategy.ui.keyword_StrategyDSL"/> + </page> + </extension> + <extension + point="org.eclipse.ui.propertyPages"> + <page + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.preferences.LanguageRootPreferencePage" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL" + icon="icons/dsl_strategy.png" + name="OSBP StrategyDSL"> + <keywordReference id="org.eclipse.osbp.xtext.strategy.ui.keyword_StrategyDSL"/> + <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.strategy.ui.keyword_StrategyDSL" + label="OSBP StrategyDSL"/> + </extension> + <extension + point="org.eclipse.ui.commands"> + <command + description="Trigger expensive validation" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.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.strategy.StrategyDSL.validate" + style="push" + tooltip="Trigger expensive validation"> + <visibleWhen checkEnabled="false"> + <reference + definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.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.strategy.StrategyDSL.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.strategy.StrategyDSL.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.strategy.StrategyDSL.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.strategy.StrategyDSL.Editor.opened"> + </reference> + </visibleWhen> + </command> + </menuContribution> + </extension> + <extension point="org.eclipse.ui.handlers"> + <handler + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.findrefs.FindReferencesHandler" + commandId="org.eclipse.xtext.ui.editor.FindReferences"> + <activeWhen> + <reference + definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.Editor.opened"> + </reference> + </activeWhen> + </handler> + </extension> + +<!-- adding resource factories --> + + <extension + point="org.eclipse.emf.ecore.extension_parser"> + <parser + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.resource.IResourceFactory" + type="strategy"> + </parser> + </extension> + <extension point="org.eclipse.xtext.extension_resourceServiceProvider"> + <resourceServiceProvider + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.resource.IResourceUIServiceProvider" + uriExtension="strategy"> + </resourceServiceProvider> + </extension> + + + <!-- marker definitions for org.eclipse.osbp.xtext.strategy.StrategyDSL --> + <extension + id="strategydsl.check.fast" + name="OSBP StrategyDSL Problem" + point="org.eclipse.core.resources.markers"> + <super type="org.eclipse.xtext.ui.check.fast"/> + <persistent value="true"/> + </extension> + <extension + id="strategydsl.check.normal" + name="OSBP StrategyDSL Problem" + point="org.eclipse.core.resources.markers"> + <super type="org.eclipse.xtext.ui.check.normal"/> + <persistent value="true"/> + </extension> + <extension + id="strategydsl.check.expensive" + name="OSBP StrategyDSL 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.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.builder.IXtextBuilderParticipant" + fileExtensions="strategy" + > + </participant> + </extension> + <extension + point="org.eclipse.ui.preferencePages"> + <page + category="org.eclipse.osbp.xtext.strategy.StrategyDSL" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.builder.preferences.BuilderPreferencePage" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.compiler.preferencePage" + icon="icons/dsl_strategy.png" + name="Compiler"> + <keywordReference id="org.eclipse.osbp.xtext.strategy.ui.keyword_StrategyDSL"/> + </page> + </extension> + <extension + point="org.eclipse.ui.propertyPages"> + <page + category="org.eclipse.osbp.xtext.strategy.StrategyDSL" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.builder.preferences.BuilderPreferencePage" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.compiler.propertyPage" + icon="icons/dsl_strategy.png" + name="Compiler"> + <keywordReference id="org.eclipse.osbp.xtext.strategy.ui.keyword_StrategyDSL"/> + <enabledWhen> + <adapt type="org.eclipse.core.resources.IProject"/> + </enabledWhen> + <filter name="projectNature" value="org.eclipse.xtext.ui.shared.xtextNature"/> + </page> + </extension> + + <!-- Quick Outline --> + <extension + point="org.eclipse.ui.handlers"> + <handler + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.outline.quickoutline.ShowQuickOutlineActionHandler" + commandId="org.eclipse.xtext.ui.editor.outline.QuickOutline"> + <activeWhen> + <reference + definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.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.strategy.StrategyDSL.Editor.opened"/> + </visibleWhen> + </command> + </menuContribution> + </extension> + <!-- quickfix marker resolution generator for org.eclipse.osbp.xtext.strategy.StrategyDSL --> + <extension + point="org.eclipse.ui.ide.markerResolution"> + <markerResolutionGenerator + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator" + markerType="org.eclipse.osbp.xtext.strategy.ui.strategydsl.check.fast"> + <attribute + name="FIXABLE_KEY" + value="true"> + </attribute> + </markerResolutionGenerator> + <markerResolutionGenerator + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator" + markerType="org.eclipse.osbp.xtext.strategy.ui.strategydsl.check.normal"> + <attribute + name="FIXABLE_KEY" + value="true"> + </attribute> + </markerResolutionGenerator> + <markerResolutionGenerator + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator" + markerType="org.eclipse.osbp.xtext.strategy.ui.strategydsl.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.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.refactoring.ui.DefaultRenameElementHandler" + commandId="org.eclipse.xtext.ui.refactoring.RenameElement"> + <activeWhen> + <reference + definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.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.strategy.StrategyDSL.Editor.opened"> + </reference> + </visibleWhen> + </command> + </menuContribution> + </extension> + <extension point="org.eclipse.ui.preferencePages"> + <page + category="org.eclipse.osbp.xtext.strategy.StrategyDSL" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.refactoring.ui.RefactoringPreferencePage" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.refactoring" + icon="icons/dsl_strategy.png" + name="Refactoring"> + <keywordReference id="org.eclipse.osbp.xtext.strategy.ui.keyword_StrategyDSL"/> + </page> + </extension> + + <extension point="org.eclipse.compare.contentViewers"> + <viewer id="org.eclipse.osbp.xtext.strategy.StrategyDSL.compare.contentViewers" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.compare.InjectableViewerCreator" + extensions="strategy"> + </viewer> + </extension> + <extension point="org.eclipse.compare.contentMergeViewers"> + <viewer id="org.eclipse.osbp.xtext.strategy.StrategyDSL.compare.contentMergeViewers" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.compare.InjectableViewerCreator" + extensions="strategy" label="StrategyDSL Compare"> + </viewer> + </extension> + <extension point="org.eclipse.ui.editors.documentProviders"> + <provider id="org.eclipse.osbp.xtext.strategy.StrategyDSL.editors.documentProviders" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.model.XtextDocumentProvider" + extensions="strategy"> + </provider> + </extension> + +</plugin> diff --git a/org.eclipse.osbp.xtext.strategy.ui/plugin.xml_gen b/org.eclipse.osbp.xtext.strategy.ui/plugin.xml_gen new file mode 100644 index 0000000..e76b09f --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/plugin.xml_gen @@ -0,0 +1,562 @@ +<?xml version="1.0" encoding="UTF-8"?> +<?eclipse version="3.0"?> + +<plugin> + + <extension + point="org.eclipse.ui.editors"> + <editor + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.XtextEditor" + contributorClass="org.eclipse.ui.editors.text.TextEditorActionContributor" + default="true" + extensions="strategy" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL" + matchingStrategy="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.editor.JavaEditorInputMatcher" + name="StrategyDSL Editor"> + </editor> + </extension> + <extension + point="org.eclipse.ui.handlers"> + <handler + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclarationHandler" + commandId="org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclaration"> + <activeWhen> + <reference + definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.Editor.opened"> + </reference> + </activeWhen> + </handler> + <handler + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.handler.ValidateActionHandler" + commandId="org.eclipse.osbp.xtext.strategy.StrategyDSL.validate"> + <activeWhen> + <reference + definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.Editor.opened"> + </reference> + </activeWhen> + </handler> + <!-- copy qualified name --> + <handler + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedNameHandler" + commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName"> + <activeWhen> + <reference definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.Editor.opened" /> + </activeWhen> + </handler> + <handler + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedNameHandler" + commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedName"> + <activeWhen> + <and> + <reference definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.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.strategy.StrategyDSL.Editor.opened"> + <and> + <reference definitionId="isActiveEditorAnInstanceOfXtextEditor"/> + <with variable="activeEditor"> + <test property="org.eclipse.xtext.ui.editor.XtextEditor.languageName" + value="org.eclipse.osbp.xtext.strategy.StrategyDSL" + forcePluginActivation="true"/> + </with> + </and> + </definition> + <definition id="org.eclipse.osbp.xtext.strategy.StrategyDSL.XtextEditor.opened"> + <and> + <reference definitionId="isXtextEditorActive"/> + <with variable="activeEditor"> + <test property="org.eclipse.xtext.ui.editor.XtextEditor.languageName" + value="org.eclipse.osbp.xtext.strategy.StrategyDSL" + forcePluginActivation="true"/> + </with> + </and> + </definition> + </extension> + <extension + point="org.eclipse.ui.preferencePages"> + <page + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.preferences.LanguageRootPreferencePage" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL" + name="StrategyDSL"> + <keywordReference id="org.eclipse.osbp.xtext.strategy.ui.keyword_StrategyDSL"/> + </page> + <page + category="org.eclipse.osbp.xtext.strategy.StrategyDSL" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.syntaxcoloring.SyntaxColoringPreferencePage" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.coloring" + name="Syntax Coloring"> + <keywordReference id="org.eclipse.osbp.xtext.strategy.ui.keyword_StrategyDSL"/> + </page> + <page + category="org.eclipse.osbp.xtext.strategy.StrategyDSL" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.templates.XtextTemplatePreferencePage" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.templates" + name="Templates"> + <keywordReference id="org.eclipse.osbp.xtext.strategy.ui.keyword_StrategyDSL"/> + </page> + </extension> + <extension + point="org.eclipse.ui.propertyPages"> + <page + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.preferences.LanguageRootPreferencePage" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL" + name="StrategyDSL"> + <keywordReference id="org.eclipse.osbp.xtext.strategy.ui.keyword_StrategyDSL"/> + <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.strategy.ui.keyword_StrategyDSL" + label="StrategyDSL"/> + </extension> + <extension + point="org.eclipse.ui.commands"> + <command + description="Trigger expensive validation" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.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.strategy.StrategyDSL.validate" + style="push" + tooltip="Trigger expensive validation"> + <visibleWhen checkEnabled="false"> + <reference + definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.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.strategy.StrategyDSL.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.strategy.StrategyDSL.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.strategy.StrategyDSL.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.strategy.StrategyDSL.Editor.opened"> + </reference> + </visibleWhen> + </command> + </menuContribution> + </extension> + <extension point="org.eclipse.ui.handlers"> + <handler + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.findrefs.FindReferencesHandler" + commandId="org.eclipse.xtext.ui.editor.FindReferences"> + <activeWhen> + <reference + definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.Editor.opened"> + </reference> + </activeWhen> + </handler> + </extension> + +<!-- adding resource factories --> + + <extension + point="org.eclipse.emf.ecore.extension_parser"> + <parser + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.resource.IResourceFactory" + type="strategy"> + </parser> + </extension> + <extension point="org.eclipse.xtext.extension_resourceServiceProvider"> + <resourceServiceProvider + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.resource.IResourceUIServiceProvider" + uriExtension="strategy"> + </resourceServiceProvider> + </extension> + + + <!-- marker definitions for org.eclipse.osbp.xtext.strategy.StrategyDSL --> + <extension + id="strategydsl.check.fast" + name="StrategyDSL Problem" + point="org.eclipse.core.resources.markers"> + <super type="org.eclipse.xtext.ui.check.fast"/> + <persistent value="true"/> + </extension> + <extension + id="strategydsl.check.normal" + name="StrategyDSL Problem" + point="org.eclipse.core.resources.markers"> + <super type="org.eclipse.xtext.ui.check.normal"/> + <persistent value="true"/> + </extension> + <extension + id="strategydsl.check.expensive" + name="StrategyDSL 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.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.builder.IXtextBuilderParticipant" + fileExtensions="strategy" + > + </participant> + </extension> + <extension + point="org.eclipse.ui.preferencePages"> + <page + category="org.eclipse.osbp.xtext.strategy.StrategyDSL" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.builder.preferences.BuilderPreferencePage" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.compiler.preferencePage" + name="Compiler"> + <keywordReference id="org.eclipse.osbp.xtext.strategy.ui.keyword_StrategyDSL"/> + </page> + </extension> + <extension + point="org.eclipse.ui.propertyPages"> + <page + category="org.eclipse.osbp.xtext.strategy.StrategyDSL" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.builder.preferences.BuilderPreferencePage" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.compiler.propertyPage" + name="Compiler"> + <keywordReference id="org.eclipse.osbp.xtext.strategy.ui.keyword_StrategyDSL"/> + <enabledWhen> + <adapt type="org.eclipse.core.resources.IProject"/> + </enabledWhen> + <filter name="projectNature" value="org.eclipse.xtext.ui.shared.xtextNature"/> + </page> + </extension> + + <!-- Quick Outline --> + <extension + point="org.eclipse.ui.handlers"> + <handler + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.outline.quickoutline.ShowQuickOutlineActionHandler" + commandId="org.eclipse.xtext.ui.editor.outline.QuickOutline"> + <activeWhen> + <reference + definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.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.strategy.StrategyDSL.Editor.opened"/> + </visibleWhen> + </command> + </menuContribution> + </extension> + <!-- quickfix marker resolution generator for org.eclipse.osbp.xtext.strategy.StrategyDSL --> + <extension + point="org.eclipse.ui.ide.markerResolution"> + <markerResolutionGenerator + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator" + markerType="org.eclipse.osbp.xtext.strategy.ui.strategydsl.check.fast"> + <attribute + name="FIXABLE_KEY" + value="true"> + </attribute> + </markerResolutionGenerator> + <markerResolutionGenerator + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator" + markerType="org.eclipse.osbp.xtext.strategy.ui.strategydsl.check.normal"> + <attribute + name="FIXABLE_KEY" + value="true"> + </attribute> + </markerResolutionGenerator> + <markerResolutionGenerator + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator" + markerType="org.eclipse.osbp.xtext.strategy.ui.strategydsl.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.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.refactoring.ui.DefaultRenameElementHandler" + commandId="org.eclipse.xtext.ui.refactoring.RenameElement"> + <activeWhen> + <reference + definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.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.strategy.StrategyDSL.Editor.opened"> + </reference> + </visibleWhen> + </command> + </menuContribution> + </extension> + <extension point="org.eclipse.ui.preferencePages"> + <page + category="org.eclipse.osbp.xtext.strategy.StrategyDSL" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.refactoring.ui.RefactoringPreferencePage" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.refactoring" + name="Refactoring"> + <keywordReference id="org.eclipse.osbp.xtext.strategy.ui.keyword_StrategyDSL"/> + </page> + </extension> + +<!-- Type Hierarchy --> + <extension + point="org.eclipse.ui.handlers"> + <handler + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.hierarchy.OpenTypeHierarchyHandler" + commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenTypeHierarchy"> + <activeWhen> + <reference + definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.Editor.opened"> + </reference> + </activeWhen> + </handler> + <handler + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.hierarchy.QuickTypeHierarchyHandler" + commandId="org.eclipse.jdt.ui.edit.text.java.open.hierarchy"> + <activeWhen> + <reference + definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.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.strategy.StrategyDSL.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.strategy.StrategyDSL.Editor.opened"/> + </visibleWhen> + </command> + </menuContribution> + </extension> + <!-- Call Hierachy --> + <extension + point="org.eclipse.ui.handlers"> + <handler + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.hierarchy.OpenCallHierachyHandler" + commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenCallHierarchy"> + <activeWhen> + <reference + definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.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.strategy.StrategyDSL.Editor.opened"/> + </visibleWhen> + </command> + </menuContribution> + </extension> + <extension + point="org.eclipse.core.runtime.adapters"> + <factory class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory: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.strategy.StrategyDSL" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.rulerActions"> + <action + label="Not Used" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.debug.ui.actions.RulerToggleBreakpointActionDelegate" + style="push" + actionID="RulerDoubleClick" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.doubleClickBreakpointAction"/> + </editorContribution> + </extension> + <extension point="org.eclipse.ui.popupMenus"> + <viewerContribution + targetID="org.eclipse.osbp.xtext.strategy.StrategyDSL.RulerContext" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.RulerPopupActions"> + <action + label="Toggle Breakpoint" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.debug.ui.actions.RulerToggleBreakpointActionDelegate" + menubarPath="debug" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.rulerContextMenu.toggleBreakpointAction"> + </action> + <action + label="Not used" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.debug.ui.actions.RulerEnableDisableBreakpointActionDelegate" + menubarPath="debug" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.rulerContextMenu.enableDisableBreakpointAction"> + </action> + <action + label="Breakpoint Properties" + helpContextId="breakpoint_properties_action_context" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.jdt.debug.ui.actions.JavaBreakpointPropertiesRulerActionDelegate" + menubarPath="group.properties" + id="org.eclipse.osbp.xtext.strategy.StrategyDSL.rulerContextMenu.openBreapointPropertiesAction"> + </action> + </viewerContribution> + </extension> + <!-- Introduce Local Variable Refactoring --> + <extension point="org.eclipse.ui.handlers"> + <handler + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.refactoring.ExtractVariableHandler" + commandId="org.eclipse.xtext.xbase.ui.refactoring.ExtractLocalVariable"> + <activeWhen> + <reference + definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.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.strategy.StrategyDSL.Editor.opened"> + </reference> + </visibleWhen> + </command> + </menuContribution> + </extension> + <!-- Open implementation --> + <extension point="org.eclipse.ui.handlers"> + <handler + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.navigation.OpenImplementationHandler" + commandId="org.eclipse.xtext.xbase.ui.OpenImplementationCommand"> + <activeWhen> + <reference + definitionId="org.eclipse.osbp.xtext.strategy.StrategyDSL.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.strategy.StrategyDSL.Editor.opened"> + </reference> + </visibleWhen> + </command> + </menuContribution> + </extension> + + <extension point="org.eclipse.compare.contentViewers"> + <viewer id="org.eclipse.osbp.xtext.strategy.StrategyDSL.compare.contentViewers" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.compare.InjectableViewerCreator" + extensions="strategy"> + </viewer> + </extension> + <extension point="org.eclipse.compare.contentMergeViewers"> + <viewer id="org.eclipse.osbp.xtext.strategy.StrategyDSL.compare.contentMergeViewers" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.compare.InjectableViewerCreator" + extensions="strategy" label="StrategyDSL Compare"> + </viewer> + </extension> + <extension point="org.eclipse.ui.editors.documentProviders"> + <provider id="org.eclipse.osbp.xtext.strategy.StrategyDSL.editors.documentProviders" + class="org.eclipse.osbp.xtext.strategy.ui.StrategyDSLExecutableExtensionFactory:org.eclipse.xtext.ui.editor.model.XtextDocumentProvider" + extensions="strategy"> + </provider> + </extension> + +</plugin> diff --git a/org.eclipse.osbp.xtext.strategy.ui/pom.xml b/org.eclipse.osbp.xtext.strategy.ui/pom.xml new file mode 100644 index 0000000..ff3dc1a --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/pom.xml @@ -0,0 +1,23 @@ +<?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: --> +<!--# Christophe Loetz (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> + <artifactId>org.eclipse.osbp.xtext.strategy.ui</artifactId> + <packaging>eclipse-plugin</packaging> + <parent> + <groupId>org.eclipse.osbp.xtext.strategy</groupId> + <artifactId>org.eclipse.osbp.xtext.strategy.aggregator</artifactId> + <version>0.9.0-SNAPSHOT</version> + <relativePath>..</relativePath> + </parent> +</project> diff --git a/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/AbstractStrategyDSLUiModule.java b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/AbstractStrategyDSLUiModule.java new file mode 100644 index 0000000..8d0120e --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/AbstractStrategyDSLUiModule.java @@ -0,0 +1,374 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + */ +package org.eclipse.osbp.xtext.strategy.ui; + +import org.eclipse.xtext.ui.DefaultUiModule; +import org.eclipse.ui.plugin.AbstractUIPlugin; + +/** + * Manual modifications go to {org.eclipse.osbp.xtext.strategy.ui.StrategyDSLUiModule} + */ +@SuppressWarnings("all") +public abstract class AbstractStrategyDSLUiModule extends DefaultUiModule { + + public AbstractStrategyDSLUiModule(AbstractUIPlugin plugin) { + super(plugin); + } + + + // contributed by org.eclipse.xtext.ui.generator.ImplicitUiFragment + public com.google.inject.Provider<org.eclipse.xtext.resource.containers.IAllContainersState> provideIAllContainersState() { + return org.eclipse.xtext.ui.shared.Access.getJavaProjectsState(); + } + + // contributed by org.eclipse.xtext.ui.generator.ImplicitUiFragment + public Class<? extends org.eclipse.xtext.ui.editor.XtextEditor> bindXtextEditor() { + return org.eclipse.xtext.xbase.ui.editor.XbaseEditor.class; + } + + // contributed by org.eclipse.xtext.ui.generator.ImplicitUiFragment + public Class<? extends org.eclipse.xtext.ui.editor.model.XtextDocumentProvider> bindXtextDocumentProvider() { + return org.eclipse.xtext.xbase.ui.editor.XbaseDocumentProvider.class; + } + + // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.contentassist.IProposalConflictHelper> bindIProposalConflictHelper() { + return org.eclipse.xtext.ui.editor.contentassist.antlr.AntlrProposalConflictHelper.class; + } + + // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment + public void configureHighlightingLexer(com.google.inject.Binder binder) { + binder.bind(org.eclipse.xtext.parser.antlr.Lexer.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.ui.LexerUIBindings.HIGHLIGHTING)).to(org.eclipse.osbp.xtext.strategy.parser.antlr.internal.InternalStrategyDSLLexer.class); + } + + // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment + public void configureHighlightingTokenDefProvider(com.google.inject.Binder binder) { + binder.bind(org.eclipse.xtext.parser.antlr.ITokenDefProvider.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.ui.LexerUIBindings.HIGHLIGHTING)).to(org.eclipse.xtext.parser.antlr.AntlrTokenDefProvider.class); + } + + // contributed by org.eclipse.xtext.generator.builder.BuilderIntegrationFragment + public void configureIResourceDescriptionsBuilderScope(com.google.inject.Binder binder) { + binder.bind(org.eclipse.xtext.resource.IResourceDescriptions.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider.NAMED_BUILDER_SCOPE)).to(org.eclipse.xtext.builder.clustering.CurrentDescriptions.ResourceSetAware.class); + } + + // contributed by org.eclipse.xtext.generator.builder.BuilderIntegrationFragment + public Class<? extends org.eclipse.xtext.ui.editor.IXtextEditorCallback> bindIXtextEditorCallback() { + return org.eclipse.xtext.builder.nature.NatureAddingEditorCallback.class; + } + + // contributed by org.eclipse.xtext.generator.builder.BuilderIntegrationFragment + public void configureIResourceDescriptionsPersisted(com.google.inject.Binder binder) { + binder.bind(org.eclipse.xtext.resource.IResourceDescriptions.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider.PERSISTED_DESCRIPTIONS)).to(org.eclipse.xtext.builder.builderState.IBuilderState.class); + } + + // contributed by org.eclipse.xtext.generator.builder.BuilderIntegrationFragment + public Class<? extends org.eclipse.xtext.ui.editor.DocumentBasedDirtyResource> bindDocumentBasedDirtyResource() { + return org.eclipse.xtext.builder.impl.PersistentDataAwareDirtyResource.class; + } + + // contributed by org.eclipse.xtext.generator.generator.GeneratorFragment + public Class<? extends org.eclipse.xtext.builder.IXtextBuilderParticipant> bindIXtextBuilderParticipant() { + return org.eclipse.xtext.builder.BuilderParticipant.class; + } + + // contributed by org.eclipse.xtext.generator.generator.GeneratorFragment + public org.eclipse.core.resources.IWorkspaceRoot bindIWorkspaceRootToInstance() { + return org.eclipse.core.resources.ResourcesPlugin.getWorkspace().getRoot(); + } + + // contributed by org.eclipse.xtext.generator.generator.GeneratorFragment + public void configureBuilderPreferenceStoreInitializer(com.google.inject.Binder binder) { + binder.bind(org.eclipse.xtext.ui.editor.preferences.IPreferenceStoreInitializer.class).annotatedWith(com.google.inject.name.Names.named("builderPreferenceInitializer")).to(org.eclipse.xtext.builder.preferences.BuilderPreferenceAccess.Initializer.class); + } + + // contributed by org.eclipse.xtext.ui.generator.labeling.LabelProviderFragment + public Class<? extends org.eclipse.jface.viewers.ILabelProvider> bindILabelProvider() { + return org.eclipse.osbp.xtext.strategy.ui.labeling.StrategyDSLLabelProvider.class; + } + + // contributed by org.eclipse.xtext.ui.generator.labeling.LabelProviderFragment + public void configureResourceUIServiceLabelProvider(com.google.inject.Binder binder) { + binder.bind(org.eclipse.jface.viewers.ILabelProvider.class).annotatedWith(org.eclipse.xtext.ui.resource.ResourceServiceDescriptionLabelProvider.class).to(org.eclipse.osbp.xtext.strategy.ui.labeling.StrategyDSLDescriptionLabelProvider.class); + } + + // contributed by org.eclipse.xtext.ui.generator.outline.OutlineTreeProviderFragment + public Class<? extends org.eclipse.xtext.ui.editor.outline.IOutlineTreeProvider> bindIOutlineTreeProvider() { + return org.eclipse.osbp.xtext.strategy.ui.outline.StrategyDSLOutlineTreeProvider.class; + } + + // contributed by org.eclipse.xtext.ui.generator.outline.OutlineTreeProviderFragment + public Class<? extends org.eclipse.xtext.ui.editor.outline.impl.IOutlineTreeStructureProvider> bindIOutlineTreeStructureProvider() { + return org.eclipse.osbp.xtext.strategy.ui.outline.StrategyDSLOutlineTreeProvider.class; + } + + // contributed by org.eclipse.xtext.ui.generator.quickfix.QuickfixProviderFragment + public Class<? extends org.eclipse.xtext.ui.editor.quickfix.IssueResolutionProvider> bindIssueResolutionProvider() { + return org.eclipse.osbp.xtext.strategy.ui.quickfix.StrategyDSLQuickfixProvider.class; + } + + // contributed by org.eclipse.xtext.ui.generator.contentAssist.ContentAssistFragment + public Class<? extends org.eclipse.xtext.ui.editor.contentassist.IContentProposalProvider> bindIContentProposalProvider() { + return org.eclipse.osbp.xtext.strategy.ui.contentassist.StrategyDSLProposalProvider.class; + } + + // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext.Factory> bindContentAssistContext$Factory() { + return org.eclipse.xtext.ui.editor.contentassist.antlr.ParserBasedContentAssistContextFactory.class; + } + + // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.contentassist.antlr.IContentAssistParser> bindIContentAssistParser() { + return org.eclipse.osbp.xtext.strategy.ui.contentassist.antlr.StrategyDSLParser.class; + } + + // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment + public void configureContentAssistLexerProvider(com.google.inject.Binder binder) { + binder.bind(org.eclipse.osbp.xtext.strategy.ui.contentassist.antlr.internal.InternalStrategyDSLLexer.class).toProvider(org.eclipse.xtext.parser.antlr.LexerProvider.create(org.eclipse.osbp.xtext.strategy.ui.contentassist.antlr.internal.InternalStrategyDSLLexer.class)); + } + + // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment + public void configureContentAssistLexer(com.google.inject.Binder binder) { + binder.bind(org.eclipse.xtext.ui.editor.contentassist.antlr.internal.Lexer.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.ui.LexerUIBindings.CONTENT_ASSIST)).to(org.eclipse.osbp.xtext.strategy.ui.contentassist.antlr.internal.InternalStrategyDSLLexer.class); + } + + // contributed by org.eclipse.xtext.ui.generator.refactoring.RefactorElementNameFragment + public void configureIPreferenceStoreInitializer(com.google.inject.Binder binder) { + binder.bind(org.eclipse.xtext.ui.editor.preferences.IPreferenceStoreInitializer.class).annotatedWith(com.google.inject.name.Names.named("RefactoringPreferences")).to(org.eclipse.xtext.ui.refactoring.ui.RefactoringPreferences.Initializer.class); + } + + // contributed by org.eclipse.xtext.ui.generator.refactoring.RefactorElementNameFragment + public Class<? extends org.eclipse.xtext.ui.refactoring.ui.IRenameSupport.Factory> bindIRenameSupport$Factory() { + return org.eclipse.xtext.common.types.ui.refactoring.JdtRenameSupport.Factory.class; + } + + // contributed by org.eclipse.xtext.ui.generator.refactoring.RefactorElementNameFragment + public Class<? extends org.eclipse.xtext.ui.refactoring.IRenameStrategy.Provider> bindIRenameStrategy$Provider() { + return org.eclipse.xtext.common.types.ui.refactoring.participant.JvmMemberRenameStrategy.Provider.class; + } + + // contributed by org.eclipse.xtext.ui.generator.refactoring.RefactorElementNameFragment + public void configureJvmMemberRenameStrategy$Provider$Delegate(com.google.inject.Binder binder) { + binder.bind(org.eclipse.xtext.ui.refactoring.IRenameStrategy.Provider.class).annotatedWith(org.eclipse.xtext.common.types.ui.refactoring.participant.JvmMemberRenameStrategy.Provider.Delegate.class).to(org.eclipse.xtext.ui.refactoring.impl.DefaultRenameStrategyProvider.class); + } + + // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment + public java.lang.ClassLoader bindClassLoaderToInstance() { + return getClass().getClassLoader(); + } + + // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment + public Class<? extends org.eclipse.xtext.common.types.access.IJvmTypeProvider.Factory> bindIJvmTypeProvider$Factory() { + return org.eclipse.xtext.common.types.access.jdt.JdtTypeProviderFactory.class; + } + + // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment + public Class<? extends org.eclipse.xtext.common.types.xtext.AbstractTypeScopeProvider> bindAbstractTypeScopeProvider() { + return org.eclipse.xtext.common.types.xtext.ui.JdtBasedSimpleTypeScopeProvider.class; + } + + // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment + public Class<? extends org.eclipse.xtext.common.types.xtext.ui.ITypesProposalProvider> bindITypesProposalProvider() { + return org.eclipse.xtext.common.types.xtext.ui.JdtTypesProposalProvider.class; + } + + // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment + public Class<? extends org.eclipse.xtext.common.types.access.jdt.IJavaProjectProvider> bindIJavaProjectProvider() { + return org.eclipse.xtext.common.types.xtext.ui.XtextResourceSetBasedProjectProvider.class; + } + + // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.contentassist.PrefixMatcher> bindPrefixMatcher() { + return org.eclipse.xtext.ui.editor.contentassist.FQNPrefixMatcher.class; + } + + // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.IValidationJobScheduler> bindIValidationJobScheduler() { + return org.eclipse.xtext.common.types.xtext.ui.JdtValidationJobScheduler.class; + } + + // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.refactoring.impl.RefactoringResourceSetProvider> bindRefactoringResourceSetProvider() { + return org.eclipse.xtext.common.types.ui.refactoring.JvmRefactoringResourceSetProvider.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.syntaxcoloring.AbstractAntlrTokenToAttributeIdMapper> bindAbstractAntlrTokenToAttributeIdMapper() { + return org.eclipse.xtext.xbase.ui.syntaxcoloring.XbaseTokenToAttributeIdMapper.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.contentassist.AbstractJavaBasedContentProposalProvider.ReferenceProposalCreator> bindAbstractJavaBasedContentProposalProvider$ReferenceProposalCreator() { + return org.eclipse.xtext.xbase.ui.contentassist.XbaseReferenceProposalCreator.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.jface.text.contentassist.IContentAssistProcessor> bindIContentAssistProcessor() { + return org.eclipse.xtext.ui.editor.contentassist.RepeatedContentAssistProcessor.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.syntaxcoloring.ISemanticHighlightingCalculator> bindISemanticHighlightingCalculator() { + return org.eclipse.xtext.xbase.ui.highlighting.XbaseHighlightingCalculator.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.syntaxcoloring.IHighlightingConfiguration> bindIHighlightingConfiguration() { + return org.eclipse.xtext.xbase.ui.highlighting.XbaseHighlightingConfiguration.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.hover.IEObjectHoverProvider> bindIEObjectHoverProvider() { + return org.eclipse.xtext.xbase.ui.hover.XbaseHoverProvider.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.hover.IEObjectHover> bindIEObjectHover() { + return org.eclipse.xtext.xbase.ui.hover.XbaseDispatchingEObjectTextHover.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.hover.html.IEObjectHoverDocumentationProvider> bindIEObjectHoverDocumentationProvider() { + return org.eclipse.xtext.xbase.ui.hover.XbaseHoverDocumentationProvider.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.quickfix.DefaultQuickfixProvider.CrossRefResolutionConverter> bindDefaultQuickfixProvider$CrossRefResolutionConverter() { + return org.eclipse.xtext.xbase.ui.quickfix.XbaseCrossRefResolutionConverter.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + @org.eclipse.xtext.service.SingletonBinding(eager=true) public Class<? extends org.eclipse.xtext.xbase.ui.validation.XbaseUIValidator> bindXbaseUIValidator() { + return org.eclipse.xtext.xbase.ui.validation.XbaseUIValidator.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.hyperlinking.IHyperlinkHelper> bindIHyperlinkHelper() { + return org.eclipse.xtext.xbase.ui.navigation.TypeLiteralAwareHyperlinkHelper.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.xbase.typesystem.internal.IFeatureScopeTracker.Provider> bindIFeatureScopeTracker$Provider() { + return org.eclipse.xtext.xbase.typesystem.internal.OptimizingFeatureScopeTrackerProvider.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.findrefs.FindReferencesHandler> bindFindReferencesHandler() { + return org.eclipse.xtext.xbase.ui.jvmmodel.findrefs.JvmModelFindReferenceHandler.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.findrefs.ReferenceQueryExecutor> bindReferenceQueryExecutor() { + return org.eclipse.xtext.xbase.ui.jvmmodel.findrefs.JvmModelReferenceQueryExecutor.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.refactoring.IDependentElementsCalculator> bindIDependentElementsCalculator() { + return org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.JvmModelDependentElementsCalculator.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.refactoring.IRenameRefactoringProvider> bindIRenameRefactoringProvider() { + return org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.jdt.CombinedJvmJdtRenameRefactoringProvider.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.refactoring.IReferenceUpdater> bindIReferenceUpdater() { + return org.eclipse.xtext.xbase.ui.refactoring.XbaseReferenceUpdater.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.refactoring.ui.IRenameContextFactory> bindIRenameContextFactory() { + return org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.jdt.CombinedJvmJdtRenameContextFactory.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.common.types.ui.refactoring.participant.JdtRenameParticipant.ContextFactory> bindJdtRenameParticipant$ContextFactory() { + return org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.JvmModelJdtRenameParticipantContext.ContextFactory.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.refactoring.IRenameStrategy> bindIRenameStrategy() { + return org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.DefaultJvmModelRenameStrategy.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.outline.impl.OutlineNodeElementOpener> bindOutlineNodeElementOpener() { + return org.eclipse.xtext.xbase.ui.jvmmodel.outline.JvmOutlineNodeElementOpener.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.GlobalURIEditorOpener> bindGlobalURIEditorOpener() { + return org.eclipse.xtext.common.types.ui.navigation.GlobalDerivedMemberAwareURIEditorOpener.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.occurrences.IOccurrenceComputer> bindIOccurrenceComputer() { + return org.eclipse.xtext.xbase.ui.jvmmodel.occurrence.JvmModelOccurrenceComputer.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.common.types.ui.query.IJavaSearchParticipation> bindIJavaSearchParticipation() { + return org.eclipse.xtext.common.types.ui.query.IJavaSearchParticipation.No.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public void configureLanguageSpecificURIEditorOpener(com.google.inject.Binder binder) { + if (org.eclipse.ui.PlatformUI.isWorkbenchRunning()) { + binder.bind(org.eclipse.xtext.ui.editor.IURIEditorOpener.class).annotatedWith(org.eclipse.xtext.ui.LanguageSpecific.class).to(org.eclipse.xtext.xbase.ui.jvmmodel.navigation.DerivedMemberAwareEditorOpener.class); + binder.bind(org.eclipse.xtext.common.types.ui.navigation.IDerivedMemberAwareEditorOpener.class).to(org.eclipse.xtext.xbase.ui.jvmmodel.navigation.DerivedMemberAwareEditorOpener.class); + }; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.jface.text.hyperlink.IHyperlinkDetector> bindIHyperlinkDetector() { + return org.eclipse.xtext.xbase.ui.navigation.XbaseHyperlinkDetector.class; + } + + // contributed by org.eclipse.xtext.generator.xbase.XbaseGeneratorFragment + public Class<? extends org.eclipse.xtext.xbase.ui.quickfix.JavaTypeQuickfixes> bindJavaTypeQuickfixes() { + return org.eclipse.xtext.xbase.ui.quickfix.JavaTypeQuickfixesNoImportSection.class; + } + + // contributed by org.eclipse.xtext.ui.generator.templates.CodetemplatesGeneratorFragment + public com.google.inject.Provider<org.eclipse.xtext.ui.codetemplates.ui.preferences.TemplatesLanguageConfiguration> provideTemplatesLanguageConfiguration() { + return org.eclipse.xtext.ui.codetemplates.ui.AccessibleCodetemplatesActivator.getTemplatesLanguageConfigurationProvider(); + } + + // contributed by org.eclipse.xtext.ui.generator.templates.CodetemplatesGeneratorFragment + public com.google.inject.Provider<org.eclipse.xtext.ui.codetemplates.ui.registry.LanguageRegistry> provideLanguageRegistry() { + return org.eclipse.xtext.ui.codetemplates.ui.AccessibleCodetemplatesActivator.getLanguageRegistry(); + } + + // contributed by org.eclipse.xtext.ui.generator.templates.CodetemplatesGeneratorFragment + @org.eclipse.xtext.service.SingletonBinding(eager=true) public Class<? extends org.eclipse.xtext.ui.codetemplates.ui.registry.LanguageRegistrar> bindLanguageRegistrar() { + return org.eclipse.xtext.ui.codetemplates.ui.registry.LanguageRegistrar.class; + } + + // contributed by org.eclipse.xtext.ui.generator.templates.CodetemplatesGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.editor.templates.XtextTemplatePreferencePage> bindXtextTemplatePreferencePage() { + return org.eclipse.xtext.ui.codetemplates.ui.preferences.AdvancedTemplatesPreferencePage.class; + } + + // contributed by org.eclipse.xtext.ui.generator.templates.CodetemplatesGeneratorFragment + public Class<? extends org.eclipse.xtext.ui.codetemplates.ui.partialEditing.IPartialContentAssistParser> bindIPartialContentAssistParser() { + return org.eclipse.osbp.xtext.strategy.ui.contentassist.antlr.PartialStrategyDSLContentAssistParser.class; + } + + // contributed by org.eclipse.xtext.ui.generator.compare.CompareFragment + public Class<? extends org.eclipse.compare.IViewerCreator> bindIViewerCreator() { + return org.eclipse.xtext.ui.compare.DefaultViewerCreator.class; + } + + +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLExecutableExtensionFactory.java b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLExecutableExtensionFactory.java new file mode 100644 index 0000000..d86339d --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLExecutableExtensionFactory.java @@ -0,0 +1,39 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + */ +package org.eclipse.osbp.xtext.strategy.ui; + +import org.eclipse.xtext.ui.guice.AbstractGuiceAwareExecutableExtensionFactory; +import org.osgi.framework.Bundle; + +import com.google.inject.Injector; + +import org.eclipse.osbp.xtext.strategy.ui.internal.StrategyDSLActivator; + +/** + * This class was generated. Customizations should only happen in a newly + * introduced subclass. + */ +public class StrategyDSLExecutableExtensionFactory extends AbstractGuiceAwareExecutableExtensionFactory { + + @Override + protected Bundle getBundle() { + return StrategyDSLActivator.getInstance().getBundle(); + } + + @Override + protected Injector getInjector() { + return StrategyDSLActivator.getInstance().getInjector(StrategyDSLActivator.ORG_ECLIPSE_OSBP_XTEXT_STRATEGY_STRATEGYDSL); + } + +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/AbstractStrategyDSLProposalProvider.java b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/AbstractStrategyDSLProposalProvider.java new file mode 100644 index 0000000..5f0ba3a --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/AbstractStrategyDSLProposalProvider.java @@ -0,0 +1,129 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + */ +package org.eclipse.osbp.xtext.strategy.ui.contentassist; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.xtext.*; +import org.eclipse.xtext.ui.editor.contentassist.ICompletionProposalAcceptor; +import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext; + +/** + * Represents a generated, default implementation of superclass {@link org.eclipse.xtext.xbase.annotations.ui.contentassist.XbaseWithAnnotationsProposalProvider}. + * Methods are dynamically dispatched on the first parameter, i.e., you can override them + * with a more concrete subtype. + */ +@SuppressWarnings("all") +public class AbstractStrategyDSLProposalProvider extends org.eclipse.xtext.xbase.annotations.ui.contentassist.XbaseWithAnnotationsProposalProvider { + + public void completeStrategyModel_Packages(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeStrategyPackage_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeStrategyPackage_Imports(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeStrategyPackage_Strategy(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeStrategyImport_ImportedNamespace(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeStrategy_Targets(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeStrategy_StrategyDefault(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeStrategyTarget_LayoutingStrategies(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeStrategyTarget_FocusingStrategies(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeStrategyTarget_FocusingEnhancer(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeLayoutingStrategy_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeLayoutingStrategy_Layout(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeFocusingStrategy_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeFocusingStrategy_EcviewFocusingId(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeFocusingStrategy_Focus(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeFocusingStrategy_KeyCode(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeFocusingStrategy_ModifierKeys(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeFocusingEnhancer_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeFocusingEnhancer_FocusingStrategies(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + lookupCrossReference(((CrossReference)assignment.getTerminal()), context, acceptor); + } + public void completeStrategyDefault_DefaultLayouting(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + lookupCrossReference(((CrossReference)assignment.getTerminal()), context, acceptor); + } + public void completeStrategyDefault_DefaultFocusing(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + lookupCrossReference(((CrossReference)assignment.getTerminal()), context, acceptor); + } + + public void complete_StrategyModel(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_StrategyPackage(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_StrategyImport(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_StrategyQualifiedNameWithWildCard(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_Strategy(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_StrategyTarget(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_LayoutingStrategy(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_FocusingStrategy(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_FocusingEnhancer(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_StrategyDefault(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_LayoutingEnum(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_FocusingEnum(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/PartialStrategyDSLContentAssistParser.java b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/PartialStrategyDSLContentAssistParser.java new file mode 100644 index 0000000..5cb9c97 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/PartialStrategyDSLContentAssistParser.java @@ -0,0 +1,48 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + */ +package org.eclipse.osbp.xtext.strategy.ui.contentassist.antlr; + +import java.util.Collection; +import java.util.Collections; + +import org.eclipse.xtext.AbstractRule; +import org.eclipse.xtext.ui.codetemplates.ui.partialEditing.IPartialContentAssistParser; +import org.eclipse.xtext.ui.editor.contentassist.antlr.FollowElement; +import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; +import org.eclipse.xtext.util.PolymorphicDispatcher; + +/** + * @author Sebastian Zarnekow - Initial contribution and API + */ +@SuppressWarnings("restriction") +public class PartialStrategyDSLContentAssistParser extends StrategyDSLParser implements IPartialContentAssistParser { + + private AbstractRule rule; + + 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.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/StrategyDSLParser.java b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/StrategyDSLParser.java new file mode 100644 index 0000000..1a5d553 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/StrategyDSLParser.java @@ -0,0 +1,513 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + */ +package org.eclipse.osbp.xtext.strategy.ui.contentassist.antlr; + +import java.util.Collection; +import java.util.Map; +import java.util.HashMap; + +import org.antlr.runtime.RecognitionException; +import org.eclipse.xtext.AbstractElement; +import org.eclipse.xtext.ui.editor.contentassist.antlr.AbstractContentAssistParser; +import org.eclipse.xtext.ui.editor.contentassist.antlr.FollowElement; +import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; + +import com.google.inject.Inject; + +import org.eclipse.osbp.xtext.strategy.services.StrategyDSLGrammarAccess; + +public class StrategyDSLParser extends AbstractContentAssistParser { + + @Inject + private StrategyDSLGrammarAccess grammarAccess; + + private Map<AbstractElement, String> nameMappings; + + @Override + protected org.eclipse.osbp.xtext.strategy.ui.contentassist.antlr.internal.InternalStrategyDSLParser createParser() { + org.eclipse.osbp.xtext.strategy.ui.contentassist.antlr.internal.InternalStrategyDSLParser result = new org.eclipse.osbp.xtext.strategy.ui.contentassist.antlr.internal.InternalStrategyDSLParser(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.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().getAlternatives_1(), "rule__XImportDeclaration__Alternatives_1"); + put(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3(), "rule__XImportDeclaration__Alternatives_1_0_3"); + put(grammarAccess.getLayoutingEnumAccess().getAlternatives(), "rule__LayoutingEnum__Alternatives"); + put(grammarAccess.getFocusingEnumAccess().getAlternatives(), "rule__FocusingEnum__Alternatives"); + put(grammarAccess.getStrategyPackageAccess().getGroup(), "rule__StrategyPackage__Group__0"); + put(grammarAccess.getStrategyPackageAccess().getGroup_3(), "rule__StrategyPackage__Group_3__0"); + put(grammarAccess.getStrategyImportAccess().getGroup(), "rule__StrategyImport__Group__0"); + put(grammarAccess.getStrategyQualifiedNameWithWildCardAccess().getGroup(), "rule__StrategyQualifiedNameWithWildCard__Group__0"); + put(grammarAccess.getStrategyQualifiedNameWithWildCardAccess().getGroup_1(), "rule__StrategyQualifiedNameWithWildCard__Group_1__0"); + put(grammarAccess.getStrategyAccess().getGroup(), "rule__Strategy__Group__0"); + put(grammarAccess.getStrategyTargetAccess().getGroup(), "rule__StrategyTarget__Group__0"); + put(grammarAccess.getStrategyTargetAccess().getGroup_2(), "rule__StrategyTarget__Group_2__0"); + put(grammarAccess.getLayoutingStrategyAccess().getGroup(), "rule__LayoutingStrategy__Group__0"); + put(grammarAccess.getFocusingStrategyAccess().getGroup(), "rule__FocusingStrategy__Group__0"); + put(grammarAccess.getFocusingStrategyAccess().getGroup_7(), "rule__FocusingStrategy__Group_7__0"); + put(grammarAccess.getFocusingStrategyAccess().getGroup_7_4(), "rule__FocusingStrategy__Group_7_4__0"); + put(grammarAccess.getFocusingEnhancerAccess().getGroup(), "rule__FocusingEnhancer__Group__0"); + put(grammarAccess.getStrategyDefaultAccess().getGroup(), "rule__StrategyDefault__Group__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.getXImportDeclarationAccess().getGroup(), "rule__XImportDeclaration__Group__0"); + put(grammarAccess.getXImportDeclarationAccess().getGroup_1_0(), "rule__XImportDeclaration__Group_1_0__0"); + put(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup(), "rule__QualifiedNameInStaticImport__Group__0"); + put(grammarAccess.getStrategyModelAccess().getPackagesAssignment(), "rule__StrategyModel__PackagesAssignment"); + put(grammarAccess.getStrategyPackageAccess().getNameAssignment_2(), "rule__StrategyPackage__NameAssignment_2"); + put(grammarAccess.getStrategyPackageAccess().getImportsAssignment_3_1(), "rule__StrategyPackage__ImportsAssignment_3_1"); + put(grammarAccess.getStrategyPackageAccess().getStrategyAssignment_3_2(), "rule__StrategyPackage__StrategyAssignment_3_2"); + put(grammarAccess.getStrategyImportAccess().getImportedNamespaceAssignment_1(), "rule__StrategyImport__ImportedNamespaceAssignment_1"); + put(grammarAccess.getStrategyAccess().getTargetsAssignment_3(), "rule__Strategy__TargetsAssignment_3"); + put(grammarAccess.getStrategyAccess().getStrategyDefaultAssignment_4(), "rule__Strategy__StrategyDefaultAssignment_4"); + put(grammarAccess.getStrategyTargetAccess().getLayoutingStrategiesAssignment_2_1(), "rule__StrategyTarget__LayoutingStrategiesAssignment_2_1"); + put(grammarAccess.getStrategyTargetAccess().getFocusingStrategiesAssignment_2_2(), "rule__StrategyTarget__FocusingStrategiesAssignment_2_2"); + put(grammarAccess.getStrategyTargetAccess().getFocusingEnhancerAssignment_2_3(), "rule__StrategyTarget__FocusingEnhancerAssignment_2_3"); + put(grammarAccess.getLayoutingStrategyAccess().getNameAssignment_2(), "rule__LayoutingStrategy__NameAssignment_2"); + put(grammarAccess.getLayoutingStrategyAccess().getLayoutAssignment_4(), "rule__LayoutingStrategy__LayoutAssignment_4"); + put(grammarAccess.getFocusingStrategyAccess().getNameAssignment_2(), "rule__FocusingStrategy__NameAssignment_2"); + put(grammarAccess.getFocusingStrategyAccess().getEcviewFocusingIdAssignment_4(), "rule__FocusingStrategy__EcviewFocusingIdAssignment_4"); + put(grammarAccess.getFocusingStrategyAccess().getFocusAssignment_6(), "rule__FocusingStrategy__FocusAssignment_6"); + put(grammarAccess.getFocusingStrategyAccess().getKeyCodeAssignment_7_3(), "rule__FocusingStrategy__KeyCodeAssignment_7_3"); + put(grammarAccess.getFocusingStrategyAccess().getModifierKeysAssignment_7_4_2(), "rule__FocusingStrategy__ModifierKeysAssignment_7_4_2"); + put(grammarAccess.getFocusingEnhancerAccess().getNameAssignment_2(), "rule__FocusingEnhancer__NameAssignment_2"); + put(grammarAccess.getFocusingEnhancerAccess().getFocusingStrategiesAssignment_4(), "rule__FocusingEnhancer__FocusingStrategiesAssignment_4"); + put(grammarAccess.getStrategyDefaultAccess().getDefaultLayoutingAssignment_4(), "rule__StrategyDefault__DefaultLayoutingAssignment_4"); + put(grammarAccess.getStrategyDefaultAccess().getDefaultFocusingAssignment_6(), "rule__StrategyDefault__DefaultFocusingAssignment_6"); + 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"); + put(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0(), "rule__XImportDeclaration__StaticAssignment_1_0_0"); + put(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1(), "rule__XImportDeclaration__ExtensionAssignment_1_0_1"); + put(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2(), "rule__XImportDeclaration__ImportedTypeAssignment_1_0_2"); + put(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0(), "rule__XImportDeclaration__WildcardAssignment_1_0_3_0"); + put(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1(), "rule__XImportDeclaration__MemberNameAssignment_1_0_3_1"); + put(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1(), "rule__XImportDeclaration__ImportedTypeAssignment_1_1"); + put(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2(), "rule__XImportDeclaration__ImportedNamespaceAssignment_1_2"); + } + }; + } + return nameMappings.get(element); + } + + @Override + protected Collection<FollowElement> getFollowElements(AbstractInternalContentAssistParser parser) { + try { + org.eclipse.osbp.xtext.strategy.ui.contentassist.antlr.internal.InternalStrategyDSLParser typedParser = (org.eclipse.osbp.xtext.strategy.ui.contentassist.antlr.internal.InternalStrategyDSLParser) parser; + typedParser.entryRuleStrategyModel(); + return typedParser.getFollowElements(); + } catch(RecognitionException ex) { + throw new RuntimeException(ex); + } + } + + @Override + protected String[] getInitialHiddenTokens() { + return new String[] { "RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT" }; + } + + public StrategyDSLGrammarAccess getGrammarAccess() { + return this.grammarAccess; + } + + public void setGrammarAccess(StrategyDSLGrammarAccess grammarAccess) { + this.grammarAccess = grammarAccess; + } +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g new file mode 100644 index 0000000..cebae64 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g @@ -0,0 +1,10014 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + */ +grammar InternalStrategyDSL; + +options { + superClass=AbstractInternalContentAssistParser; + backtrack=true; + +} + +@lexer::header { +package org.eclipse.osbp.xtext.strategy.ui.contentassist.antlr.internal; + +// Hack: Use our own Lexer superclass by means of import. +// Currently there is no other way to specify the superclass for the lexer. +import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.Lexer; +} + +@parser::header { +package org.eclipse.osbp.xtext.strategy.ui.contentassist.antlr.internal; + +import java.io.InputStream; +import org.eclipse.xtext.*; +import org.eclipse.xtext.parser.*; +import org.eclipse.xtext.parser.impl.*; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; +import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; +import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; +import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.DFA; +import org.eclipse.osbp.xtext.strategy.services.StrategyDSLGrammarAccess; + +} + +@parser::members { + + private StrategyDSLGrammarAccess grammarAccess; + + public void setGrammarAccess(StrategyDSLGrammarAccess grammarAccess) { + this.grammarAccess = grammarAccess; + } + + @Override + protected Grammar getGrammar() { + return grammarAccess.getGrammar(); + } + + @Override + protected String getValueForTokenName(String tokenName) { + return tokenName; + } + +} + + + + +// Entry rule entryRuleStrategyModel +entryRuleStrategyModel +: +{ before(grammarAccess.getStrategyModelRule()); } + ruleStrategyModel +{ after(grammarAccess.getStrategyModelRule()); } + EOF +; + +// Rule StrategyModel +ruleStrategyModel + @init { + int stackSize = keepStackSize(); + } + : +( +{ before(grammarAccess.getStrategyModelAccess().getPackagesAssignment()); } +(rule__StrategyModel__PackagesAssignment)* +{ after(grammarAccess.getStrategyModelAccess().getPackagesAssignment()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + +// Entry rule entryRuleStrategyPackage +entryRuleStrategyPackage +: +{ before(grammarAccess.getStrategyPackageRule()); } + ruleStrategyPackage +{ after(grammarAccess.getStrategyPackageRule()); } + EOF +; + +// Rule StrategyPackage +ruleStrategyPackage + @init { + int stackSize = keepStackSize(); + } + : +( +{ before(grammarAccess.getStrategyPackageAccess().getGroup()); } +(rule__StrategyPackage__Group__0) +{ after(grammarAccess.getStrategyPackageAccess().getGroup()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + +// Entry rule entryRuleStrategyImport +entryRuleStrategyImport +: +{ before(grammarAccess.getStrategyImportRule()); } + ruleStrategyImport +{ after(grammarAccess.getStrategyImportRule()); } + EOF +; + +// Rule StrategyImport +ruleStrategyImport + @init { + int stackSize = keepStackSize(); + } + : +( +{ before(grammarAccess.getStrategyImportAccess().getGroup()); } +(rule__StrategyImport__Group__0) +{ after(grammarAccess.getStrategyImportAccess().getGroup()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + +// Entry rule entryRuleStrategyQualifiedNameWithWildCard +entryRuleStrategyQualifiedNameWithWildCard +: +{ before(grammarAccess.getStrategyQualifiedNameWithWildCardRule()); } + ruleStrategyQualifiedNameWithWildCard +{ after(grammarAccess.getStrategyQualifiedNameWithWildCardRule()); } + EOF +; + +// Rule StrategyQualifiedNameWithWildCard +ruleStrategyQualifiedNameWithWildCard + @init { + int stackSize = keepStackSize(); + } + : +( +{ before(grammarAccess.getStrategyQualifiedNameWithWildCardAccess().getGroup()); } +(rule__StrategyQualifiedNameWithWildCard__Group__0) +{ after(grammarAccess.getStrategyQualifiedNameWithWildCardAccess().getGroup()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + +// Entry rule entryRuleStrategy +entryRuleStrategy +: +{ before(grammarAccess.getStrategyRule()); } + ruleStrategy +{ after(grammarAccess.getStrategyRule()); } + EOF +; + +// Rule Strategy +ruleStrategy + @init { + int stackSize = keepStackSize(); + } + : +( +{ before(grammarAccess.getStrategyAccess().getGroup()); } +(rule__Strategy__Group__0) +{ after(grammarAccess.getStrategyAccess().getGroup()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + +// Entry rule entryRuleStrategyTarget +entryRuleStrategyTarget +: +{ before(grammarAccess.getStrategyTargetRule()); } + ruleStrategyTarget +{ after(grammarAccess.getStrategyTargetRule()); } + EOF +; + +// Rule StrategyTarget +ruleStrategyTarget + @init { + int stackSize = keepStackSize(); + } + : +( +{ before(grammarAccess.getStrategyTargetAccess().getGroup()); } +(rule__StrategyTarget__Group__0) +{ after(grammarAccess.getStrategyTargetAccess().getGroup()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + +// Entry rule entryRuleLayoutingStrategy +entryRuleLayoutingStrategy +: +{ before(grammarAccess.getLayoutingStrategyRule()); } + ruleLayoutingStrategy +{ after(grammarAccess.getLayoutingStrategyRule()); } + EOF +; + +// Rule LayoutingStrategy +ruleLayoutingStrategy + @init { + int stackSize = keepStackSize(); + } + : +( +{ before(grammarAccess.getLayoutingStrategyAccess().getGroup()); } +(rule__LayoutingStrategy__Group__0) +{ after(grammarAccess.getLayoutingStrategyAccess().getGroup()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + +// Entry rule entryRuleFocusingStrategy +entryRuleFocusingStrategy +: +{ before(grammarAccess.getFocusingStrategyRule()); } + ruleFocusingStrategy +{ after(grammarAccess.getFocusingStrategyRule()); } + EOF +; + +// Rule FocusingStrategy +ruleFocusingStrategy + @init { + int stackSize = keepStackSize(); + } + : +( +{ before(grammarAccess.getFocusingStrategyAccess().getGroup()); } +(rule__FocusingStrategy__Group__0) +{ after(grammarAccess.getFocusingStrategyAccess().getGroup()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + +// Entry rule entryRuleFocusingEnhancer +entryRuleFocusingEnhancer +: +{ before(grammarAccess.getFocusingEnhancerRule()); } + ruleFocusingEnhancer +{ after(grammarAccess.getFocusingEnhancerRule()); } + EOF +; + +// Rule FocusingEnhancer +ruleFocusingEnhancer + @init { + int stackSize = keepStackSize(); + } + : +( +{ before(grammarAccess.getFocusingEnhancerAccess().getGroup()); } +(rule__FocusingEnhancer__Group__0) +{ after(grammarAccess.getFocusingEnhancerAccess().getGroup()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + +// Entry rule entryRuleStrategyDefault +entryRuleStrategyDefault +: +{ before(grammarAccess.getStrategyDefaultRule()); } + ruleStrategyDefault +{ after(grammarAccess.getStrategyDefaultRule()); } + EOF +; + +// Rule StrategyDefault +ruleStrategyDefault + @init { + int stackSize = keepStackSize(); + } + : +( +{ before(grammarAccess.getStrategyDefaultAccess().getGroup()); } +(rule__StrategyDefault__Group__0) +{ after(grammarAccess.getStrategyDefaultAccess().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 entryRuleXImportDeclaration +entryRuleXImportDeclaration +: +{ before(grammarAccess.getXImportDeclarationRule()); } + ruleXImportDeclaration +{ after(grammarAccess.getXImportDeclarationRule()); } + EOF +; + +// Rule XImportDeclaration +ruleXImportDeclaration + @init { + int stackSize = keepStackSize(); + } + : +( +{ before(grammarAccess.getXImportDeclarationAccess().getGroup()); } +(rule__XImportDeclaration__Group__0) +{ after(grammarAccess.getXImportDeclarationAccess().getGroup()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + +// Entry rule entryRuleQualifiedNameInStaticImport +entryRuleQualifiedNameInStaticImport +: +{ before(grammarAccess.getQualifiedNameInStaticImportRule()); } + ruleQualifiedNameInStaticImport +{ after(grammarAccess.getQualifiedNameInStaticImportRule()); } + EOF +; + +// Rule QualifiedNameInStaticImport +ruleQualifiedNameInStaticImport + @init { + int stackSize = keepStackSize(); + } + : +( +( +{ before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } +(rule__QualifiedNameInStaticImport__Group__0) +{ after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } +) +( +{ before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } +(rule__QualifiedNameInStaticImport__Group__0)* +{ after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } +) +) + +; +finally { + restoreStackSize(stackSize); +} + + + + +// Rule LayoutingEnum +ruleLayoutingEnum + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getLayoutingEnumAccess().getAlternatives()); } +(rule__LayoutingEnum__Alternatives) +{ after(grammarAccess.getLayoutingEnumAccess().getAlternatives()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + +// Rule FocusingEnum +ruleFocusingEnum + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingEnumAccess().getAlternatives()); } +(rule__FocusingEnum__Alternatives) +{ after(grammarAccess.getFocusingEnumAccess().getAlternatives()); } +) + +; +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__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); } +(rule__XImportDeclaration__Group_1_0__0) +{ after(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); } +) + + |( +{ before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); } +(rule__XImportDeclaration__ImportedTypeAssignment_1_1) +{ after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); } +) + + |( +{ before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); } +(rule__XImportDeclaration__ImportedNamespaceAssignment_1_2) +{ after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); } +) + +; +finally { + restoreStackSize(stackSize); +} + +rule__XImportDeclaration__Alternatives_1_0_3 + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); } +(rule__XImportDeclaration__WildcardAssignment_1_0_3_0) +{ after(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); } +) + + |( +{ before(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); } +(rule__XImportDeclaration__MemberNameAssignment_1_0_3_1) +{ after(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); } +) + +; +finally { + restoreStackSize(stackSize); +} + +rule__LayoutingEnum__Alternatives + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getLayoutingEnumAccess().getHORIZONTALEnumLiteralDeclaration_0()); } +( 'Horizontal' +) +{ after(grammarAccess.getLayoutingEnumAccess().getHORIZONTALEnumLiteralDeclaration_0()); } +) + + |( +{ before(grammarAccess.getLayoutingEnumAccess().getVERTICALEnumLiteralDeclaration_1()); } +( 'Vertical' +) +{ after(grammarAccess.getLayoutingEnumAccess().getVERTICALEnumLiteralDeclaration_1()); } +) + + |( +{ before(grammarAccess.getLayoutingEnumAccess().getGRIDEnumLiteralDeclaration_2()); } +( 'Grid' +) +{ after(grammarAccess.getLayoutingEnumAccess().getGRIDEnumLiteralDeclaration_2()); } +) + + |( +{ before(grammarAccess.getLayoutingEnumAccess().getFORM2EnumLiteralDeclaration_3()); } +( 'Form2' +) +{ after(grammarAccess.getLayoutingEnumAccess().getFORM2EnumLiteralDeclaration_3()); } +) + + |( +{ before(grammarAccess.getLayoutingEnumAccess().getFORM3EnumLiteralDeclaration_4()); } +( 'Form3' +) +{ after(grammarAccess.getLayoutingEnumAccess().getFORM3EnumLiteralDeclaration_4()); } +) + + |( +{ before(grammarAccess.getLayoutingEnumAccess().getCSSEnumLiteralDeclaration_5()); } +( 'Css' +) +{ after(grammarAccess.getLayoutingEnumAccess().getCSSEnumLiteralDeclaration_5()); } +) + +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingEnum__Alternatives + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingEnumAccess().getFORWARDEnumLiteralDeclaration_0()); } +( 'Forward' +) +{ after(grammarAccess.getFocusingEnumAccess().getFORWARDEnumLiteralDeclaration_0()); } +) + + |( +{ before(grammarAccess.getFocusingEnumAccess().getBACKWARDEnumLiteralDeclaration_1()); } +( 'Backward' +) +{ after(grammarAccess.getFocusingEnumAccess().getBACKWARDEnumLiteralDeclaration_1()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + +rule__StrategyPackage__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyPackage__Group__0__Impl + rule__StrategyPackage__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyPackage__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyPackageAccess().getStrategyPackageAction_0()); } +( + +) +{ after(grammarAccess.getStrategyPackageAccess().getStrategyPackageAction_0()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyPackage__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyPackage__Group__1__Impl + rule__StrategyPackage__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyPackage__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyPackageAccess().getPackageKeyword_1()); } + + 'package' + +{ after(grammarAccess.getStrategyPackageAccess().getPackageKeyword_1()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyPackage__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyPackage__Group__2__Impl + rule__StrategyPackage__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyPackage__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyPackageAccess().getNameAssignment_2()); } +(rule__StrategyPackage__NameAssignment_2) +{ after(grammarAccess.getStrategyPackageAccess().getNameAssignment_2()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyPackage__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyPackage__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyPackage__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyPackageAccess().getGroup_3()); } +(rule__StrategyPackage__Group_3__0)? +{ after(grammarAccess.getStrategyPackageAccess().getGroup_3()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + + + + + + + + +rule__StrategyPackage__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyPackage__Group_3__0__Impl + rule__StrategyPackage__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyPackage__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyPackageAccess().getLeftCurlyBracketKeyword_3_0()); } + + '{' + +{ after(grammarAccess.getStrategyPackageAccess().getLeftCurlyBracketKeyword_3_0()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyPackage__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyPackage__Group_3__1__Impl + rule__StrategyPackage__Group_3__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyPackage__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyPackageAccess().getImportsAssignment_3_1()); } +(rule__StrategyPackage__ImportsAssignment_3_1)* +{ after(grammarAccess.getStrategyPackageAccess().getImportsAssignment_3_1()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyPackage__Group_3__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyPackage__Group_3__2__Impl + rule__StrategyPackage__Group_3__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyPackage__Group_3__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyPackageAccess().getStrategyAssignment_3_2()); } +(rule__StrategyPackage__StrategyAssignment_3_2) +{ after(grammarAccess.getStrategyPackageAccess().getStrategyAssignment_3_2()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyPackage__Group_3__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyPackage__Group_3__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyPackage__Group_3__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyPackageAccess().getRightCurlyBracketKeyword_3_3()); } + + '}' + +{ after(grammarAccess.getStrategyPackageAccess().getRightCurlyBracketKeyword_3_3()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + + + + + + + + +rule__StrategyImport__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyImport__Group__0__Impl + rule__StrategyImport__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyImport__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyImportAccess().getImportKeyword_0()); } + + 'import' + +{ after(grammarAccess.getStrategyImportAccess().getImportKeyword_0()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyImport__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyImport__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyImport__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyImportAccess().getImportedNamespaceAssignment_1()); } +(rule__StrategyImport__ImportedNamespaceAssignment_1) +{ after(grammarAccess.getStrategyImportAccess().getImportedNamespaceAssignment_1()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + + + + +rule__StrategyQualifiedNameWithWildCard__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyQualifiedNameWithWildCard__Group__0__Impl + rule__StrategyQualifiedNameWithWildCard__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyQualifiedNameWithWildCard__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyQualifiedNameWithWildCardAccess().getQualifiedNameParserRuleCall_0()); } + ruleQualifiedName +{ after(grammarAccess.getStrategyQualifiedNameWithWildCardAccess().getQualifiedNameParserRuleCall_0()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyQualifiedNameWithWildCard__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyQualifiedNameWithWildCard__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyQualifiedNameWithWildCard__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyQualifiedNameWithWildCardAccess().getGroup_1()); } +(rule__StrategyQualifiedNameWithWildCard__Group_1__0)? +{ after(grammarAccess.getStrategyQualifiedNameWithWildCardAccess().getGroup_1()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + + + + +rule__StrategyQualifiedNameWithWildCard__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyQualifiedNameWithWildCard__Group_1__0__Impl + rule__StrategyQualifiedNameWithWildCard__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyQualifiedNameWithWildCard__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyQualifiedNameWithWildCardAccess().getFullStopKeyword_1_0()); } + + '.' + +{ after(grammarAccess.getStrategyQualifiedNameWithWildCardAccess().getFullStopKeyword_1_0()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyQualifiedNameWithWildCard__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyQualifiedNameWithWildCard__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyQualifiedNameWithWildCard__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyQualifiedNameWithWildCardAccess().getAsteriskKeyword_1_1()); } + + '*' + +{ after(grammarAccess.getStrategyQualifiedNameWithWildCardAccess().getAsteriskKeyword_1_1()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + + + + +rule__Strategy__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Strategy__Group__0__Impl + rule__Strategy__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Strategy__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyAccess().getStrategyAction_0()); } +( + +) +{ after(grammarAccess.getStrategyAccess().getStrategyAction_0()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__Strategy__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Strategy__Group__1__Impl + rule__Strategy__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Strategy__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyAccess().getStrategyKeyword_1()); } + + 'strategy' + +{ after(grammarAccess.getStrategyAccess().getStrategyKeyword_1()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__Strategy__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Strategy__Group__2__Impl + rule__Strategy__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Strategy__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyAccess().getLeftCurlyBracketKeyword_2()); } + + '{' + +{ after(grammarAccess.getStrategyAccess().getLeftCurlyBracketKeyword_2()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__Strategy__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Strategy__Group__3__Impl + rule__Strategy__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__Strategy__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyAccess().getTargetsAssignment_3()); } +(rule__Strategy__TargetsAssignment_3) +{ after(grammarAccess.getStrategyAccess().getTargetsAssignment_3()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__Strategy__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__Strategy__Group__4__Impl + rule__Strategy__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__Strategy__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyAccess().getStrategyDefaultAssignment_4()); } +(rule__Strategy__StrategyDefaultAssignment_4) +{ after(grammarAccess.getStrategyAccess().getStrategyDefaultAssignment_4()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__Strategy__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__Strategy__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Strategy__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyAccess().getRightCurlyBracketKeyword_5()); } + + '}' + +{ after(grammarAccess.getStrategyAccess().getRightCurlyBracketKeyword_5()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + + + + + + + + + + + + +rule__StrategyTarget__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyTarget__Group__0__Impl + rule__StrategyTarget__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyTarget__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyTargetAccess().getStrategyTargetAction_0()); } +( + +) +{ after(grammarAccess.getStrategyTargetAccess().getStrategyTargetAction_0()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyTarget__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyTarget__Group__1__Impl + rule__StrategyTarget__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyTarget__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyTargetAccess().getTargetsKeyword_1()); } + + 'targets' + +{ after(grammarAccess.getStrategyTargetAccess().getTargetsKeyword_1()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyTarget__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyTarget__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyTarget__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyTargetAccess().getGroup_2()); } +(rule__StrategyTarget__Group_2__0)? +{ after(grammarAccess.getStrategyTargetAccess().getGroup_2()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + + + + + + +rule__StrategyTarget__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyTarget__Group_2__0__Impl + rule__StrategyTarget__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyTarget__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyTargetAccess().getLeftCurlyBracketKeyword_2_0()); } + + '{' + +{ after(grammarAccess.getStrategyTargetAccess().getLeftCurlyBracketKeyword_2_0()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyTarget__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyTarget__Group_2__1__Impl + rule__StrategyTarget__Group_2__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyTarget__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyTargetAccess().getLayoutingStrategiesAssignment_2_1()); } +(rule__StrategyTarget__LayoutingStrategiesAssignment_2_1)* +{ after(grammarAccess.getStrategyTargetAccess().getLayoutingStrategiesAssignment_2_1()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyTarget__Group_2__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyTarget__Group_2__2__Impl + rule__StrategyTarget__Group_2__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyTarget__Group_2__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyTargetAccess().getFocusingStrategiesAssignment_2_2()); } +(rule__StrategyTarget__FocusingStrategiesAssignment_2_2)* +{ after(grammarAccess.getStrategyTargetAccess().getFocusingStrategiesAssignment_2_2()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyTarget__Group_2__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyTarget__Group_2__3__Impl + rule__StrategyTarget__Group_2__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyTarget__Group_2__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyTargetAccess().getFocusingEnhancerAssignment_2_3()); } +(rule__StrategyTarget__FocusingEnhancerAssignment_2_3)* +{ after(grammarAccess.getStrategyTargetAccess().getFocusingEnhancerAssignment_2_3()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyTarget__Group_2__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyTarget__Group_2__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyTarget__Group_2__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyTargetAccess().getRightCurlyBracketKeyword_2_4()); } + + '}' + +{ after(grammarAccess.getStrategyTargetAccess().getRightCurlyBracketKeyword_2_4()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + + + + + + + + + + +rule__LayoutingStrategy__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__LayoutingStrategy__Group__0__Impl + rule__LayoutingStrategy__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__LayoutingStrategy__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getLayoutingStrategyAccess().getLayoutingStrategyAction_0()); } +( + +) +{ after(grammarAccess.getLayoutingStrategyAccess().getLayoutingStrategyAction_0()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__LayoutingStrategy__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__LayoutingStrategy__Group__1__Impl + rule__LayoutingStrategy__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__LayoutingStrategy__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getLayoutingStrategyAccess().getLayoutingStrategyKeyword_1()); } + + 'layoutingStrategy' + +{ after(grammarAccess.getLayoutingStrategyAccess().getLayoutingStrategyKeyword_1()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__LayoutingStrategy__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__LayoutingStrategy__Group__2__Impl + rule__LayoutingStrategy__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__LayoutingStrategy__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getLayoutingStrategyAccess().getNameAssignment_2()); } +(rule__LayoutingStrategy__NameAssignment_2) +{ after(grammarAccess.getLayoutingStrategyAccess().getNameAssignment_2()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__LayoutingStrategy__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__LayoutingStrategy__Group__3__Impl + rule__LayoutingStrategy__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__LayoutingStrategy__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getLayoutingStrategyAccess().getLayoutKeyword_3()); } + + 'layout=' + +{ after(grammarAccess.getLayoutingStrategyAccess().getLayoutKeyword_3()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__LayoutingStrategy__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__LayoutingStrategy__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__LayoutingStrategy__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getLayoutingStrategyAccess().getLayoutAssignment_4()); } +(rule__LayoutingStrategy__LayoutAssignment_4) +{ after(grammarAccess.getLayoutingStrategyAccess().getLayoutAssignment_4()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + + + + + + + + + + +rule__FocusingStrategy__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group__0__Impl + rule__FocusingStrategy__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getFocusingStrategyAction_0()); } +( + +) +{ after(grammarAccess.getFocusingStrategyAccess().getFocusingStrategyAction_0()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingStrategy__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group__1__Impl + rule__FocusingStrategy__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getFocusingStrategyKeyword_1()); } + + 'focusingStrategy' + +{ after(grammarAccess.getFocusingStrategyAccess().getFocusingStrategyKeyword_1()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingStrategy__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group__2__Impl + rule__FocusingStrategy__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getNameAssignment_2()); } +(rule__FocusingStrategy__NameAssignment_2) +{ after(grammarAccess.getFocusingStrategyAccess().getNameAssignment_2()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingStrategy__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group__3__Impl + rule__FocusingStrategy__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getEcviewFocusingIdKeyword_3()); } + + 'ecviewFocusingId=' + +{ after(grammarAccess.getFocusingStrategyAccess().getEcviewFocusingIdKeyword_3()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingStrategy__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group__4__Impl + rule__FocusingStrategy__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getEcviewFocusingIdAssignment_4()); } +(rule__FocusingStrategy__EcviewFocusingIdAssignment_4) +{ after(grammarAccess.getFocusingStrategyAccess().getEcviewFocusingIdAssignment_4()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingStrategy__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group__5__Impl + rule__FocusingStrategy__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getFocusKeyword_5()); } + + 'focus=' + +{ after(grammarAccess.getFocusingStrategyAccess().getFocusKeyword_5()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingStrategy__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group__6__Impl + rule__FocusingStrategy__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getFocusAssignment_6()); } +(rule__FocusingStrategy__FocusAssignment_6) +{ after(grammarAccess.getFocusingStrategyAccess().getFocusAssignment_6()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingStrategy__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getGroup_7()); } +(rule__FocusingStrategy__Group_7__0)? +{ after(grammarAccess.getFocusingStrategyAccess().getGroup_7()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + + + + + + + + + + + + + + + + +rule__FocusingStrategy__Group_7__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group_7__0__Impl + rule__FocusingStrategy__Group_7__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group_7__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getKeyStrokeDefinitionKeyword_7_0()); } + + 'keyStrokeDefinition' + +{ after(grammarAccess.getFocusingStrategyAccess().getKeyStrokeDefinitionKeyword_7_0()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingStrategy__Group_7__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group_7__1__Impl + rule__FocusingStrategy__Group_7__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group_7__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getLeftCurlyBracketKeyword_7_1()); } + + '{' + +{ after(grammarAccess.getFocusingStrategyAccess().getLeftCurlyBracketKeyword_7_1()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingStrategy__Group_7__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group_7__2__Impl + rule__FocusingStrategy__Group_7__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group_7__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getKeyCodeKeyword_7_2()); } + + 'keyCode=' + +{ after(grammarAccess.getFocusingStrategyAccess().getKeyCodeKeyword_7_2()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingStrategy__Group_7__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group_7__3__Impl + rule__FocusingStrategy__Group_7__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group_7__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getKeyCodeAssignment_7_3()); } +(rule__FocusingStrategy__KeyCodeAssignment_7_3) +{ after(grammarAccess.getFocusingStrategyAccess().getKeyCodeAssignment_7_3()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingStrategy__Group_7__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group_7__4__Impl + rule__FocusingStrategy__Group_7__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group_7__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getGroup_7_4()); } +(rule__FocusingStrategy__Group_7_4__0)? +{ after(grammarAccess.getFocusingStrategyAccess().getGroup_7_4()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingStrategy__Group_7__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group_7__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group_7__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getRightCurlyBracketKeyword_7_5()); } + + '}' + +{ after(grammarAccess.getFocusingStrategyAccess().getRightCurlyBracketKeyword_7_5()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + + + + + + + + + + + + +rule__FocusingStrategy__Group_7_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group_7_4__0__Impl + rule__FocusingStrategy__Group_7_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group_7_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getModifierKeysKeyword_7_4_0()); } + + 'modifierKeys' + +{ after(grammarAccess.getFocusingStrategyAccess().getModifierKeysKeyword_7_4_0()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingStrategy__Group_7_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group_7_4__1__Impl + rule__FocusingStrategy__Group_7_4__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group_7_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getLeftCurlyBracketKeyword_7_4_1()); } + + '{' + +{ after(grammarAccess.getFocusingStrategyAccess().getLeftCurlyBracketKeyword_7_4_1()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingStrategy__Group_7_4__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group_7_4__2__Impl + rule__FocusingStrategy__Group_7_4__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group_7_4__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getModifierKeysAssignment_7_4_2()); } +(rule__FocusingStrategy__ModifierKeysAssignment_7_4_2)* +{ after(grammarAccess.getFocusingStrategyAccess().getModifierKeysAssignment_7_4_2()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingStrategy__Group_7_4__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingStrategy__Group_7_4__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingStrategy__Group_7_4__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingStrategyAccess().getRightCurlyBracketKeyword_7_4_3()); } + + '}' + +{ after(grammarAccess.getFocusingStrategyAccess().getRightCurlyBracketKeyword_7_4_3()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + + + + + + + + +rule__FocusingEnhancer__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingEnhancer__Group__0__Impl + rule__FocusingEnhancer__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingEnhancer__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingEnhancerAccess().getFocusingEnhancerAction_0()); } +( + +) +{ after(grammarAccess.getFocusingEnhancerAccess().getFocusingEnhancerAction_0()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingEnhancer__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingEnhancer__Group__1__Impl + rule__FocusingEnhancer__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingEnhancer__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingEnhancerAccess().getFocusingEnhancerKeyword_1()); } + + 'focusingEnhancer' + +{ after(grammarAccess.getFocusingEnhancerAccess().getFocusingEnhancerKeyword_1()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingEnhancer__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingEnhancer__Group__2__Impl + rule__FocusingEnhancer__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingEnhancer__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingEnhancerAccess().getNameAssignment_2()); } +(rule__FocusingEnhancer__NameAssignment_2) +{ after(grammarAccess.getFocusingEnhancerAccess().getNameAssignment_2()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingEnhancer__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingEnhancer__Group__3__Impl + rule__FocusingEnhancer__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingEnhancer__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingEnhancerAccess().getLeftCurlyBracketKeyword_3()); } + + '{' + +{ after(grammarAccess.getFocusingEnhancerAccess().getLeftCurlyBracketKeyword_3()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingEnhancer__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingEnhancer__Group__4__Impl + rule__FocusingEnhancer__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingEnhancer__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +( +{ before(grammarAccess.getFocusingEnhancerAccess().getFocusingStrategiesAssignment_4()); } +(rule__FocusingEnhancer__FocusingStrategiesAssignment_4) +{ after(grammarAccess.getFocusingEnhancerAccess().getFocusingStrategiesAssignment_4()); } +) +( +{ before(grammarAccess.getFocusingEnhancerAccess().getFocusingStrategiesAssignment_4()); } +(rule__FocusingEnhancer__FocusingStrategiesAssignment_4)* +{ after(grammarAccess.getFocusingEnhancerAccess().getFocusingStrategiesAssignment_4()); } +) +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__FocusingEnhancer__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__FocusingEnhancer__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__FocusingEnhancer__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getFocusingEnhancerAccess().getRightCurlyBracketKeyword_5()); } + + '}' + +{ after(grammarAccess.getFocusingEnhancerAccess().getRightCurlyBracketKeyword_5()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + + + + + + + + + + + + + +rule__StrategyDefault__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyDefault__Group__0__Impl + rule__StrategyDefault__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyDefault__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyDefaultAccess().getStrategyDefaultAction_0()); } +( + +) +{ after(grammarAccess.getStrategyDefaultAccess().getStrategyDefaultAction_0()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyDefault__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyDefault__Group__1__Impl + rule__StrategyDefault__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyDefault__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyDefaultAccess().getDefaultKeyword_1()); } + + 'default' + +{ after(grammarAccess.getStrategyDefaultAccess().getDefaultKeyword_1()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyDefault__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyDefault__Group__2__Impl + rule__StrategyDefault__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyDefault__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyDefaultAccess().getLeftCurlyBracketKeyword_2()); } + + '{' + +{ after(grammarAccess.getStrategyDefaultAccess().getLeftCurlyBracketKeyword_2()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyDefault__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyDefault__Group__3__Impl + rule__StrategyDefault__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyDefault__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyDefaultAccess().getDefaultLayoutingKeyword_3()); } + + 'defaultLayouting=' + +{ after(grammarAccess.getStrategyDefaultAccess().getDefaultLayoutingKeyword_3()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyDefault__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyDefault__Group__4__Impl + rule__StrategyDefault__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyDefault__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyDefaultAccess().getDefaultLayoutingAssignment_4()); } +(rule__StrategyDefault__DefaultLayoutingAssignment_4) +{ after(grammarAccess.getStrategyDefaultAccess().getDefaultLayoutingAssignment_4()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyDefault__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyDefault__Group__5__Impl + rule__StrategyDefault__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyDefault__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyDefaultAccess().getDefaultFocusingKeyword_5()); } + + 'defaultFocusing=' + +{ after(grammarAccess.getStrategyDefaultAccess().getDefaultFocusingKeyword_5()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyDefault__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyDefault__Group__6__Impl + rule__StrategyDefault__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyDefault__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyDefaultAccess().getDefaultFocusingAssignment_6()); } +(rule__StrategyDefault__DefaultFocusingAssignment_6) +{ after(grammarAccess.getStrategyDefaultAccess().getDefaultFocusingAssignment_6()); } +) + +; +finally { + restoreStackSize(stackSize); +} + + +rule__StrategyDefault__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__StrategyDefault__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__StrategyDefault__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( +{ before(grammarAccess.getStrategyDefaultAccess().getRightCurlyBracketKeyword_7()); } + + '}' + +{ after(grammarAccess.getStrategyDefaultAccess().getRightCurlyBracketKeyword_7()); } +) + +; +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(); + } diff --git a/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.tokens b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.tokens new file mode 100644 index 0000000..65421af --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.tokens @@ -0,0 +1,203 @@ +'!'=40 +'!='=22 +'!=='=24 +'#'=81 +'%'=39 +'%='=20 +'&&'=15 +'&'=104 +'('=77 +')'=78 +'*'=36 +'**'=37 +'*='=18 +'+'=34 +'++'=41 +'+='=16 +','=79 +'-'=35 +'--'=42 +'-='=17 +'->'=28 +'.'=43 +'..'=30 +'..<'=29 +'/'=38 +'/='=19 +':'=89 +'::'=105 +';'=85 +'<'=27 +'<>'=32 +'='=13 +'=='=21 +'==='=23 +'=>'=31 +'>'=26 +'>='=25 +'?'=103 +'?.'=106 +'?:'=33 +'@'=76 +'Backward'=58 +'Css'=56 +'Form2'=54 +'Form3'=55 +'Forward'=57 +'Grid'=53 +'Horizontal'=51 +'Vertical'=52 +'['=82 +']'=80 +'as'=84 +'case'=90 +'catch'=102 +'default'=73 +'defaultFocusing='=75 +'defaultLayouting='=74 +'do'=93 +'ecviewFocusingId='=67 +'else'=87 +'extends'=45 +'extension'=48 +'false'=50 +'finally'=100 +'focus='=68 +'focusingEnhancer'=72 +'focusingStrategy'=66 +'for'=91 +'if'=86 +'import'=47 +'instanceof'=83 +'keyCode='=70 +'keyStrokeDefinition'=69 +'layout='=65 +'layoutingStrategy'=64 +'modifierKeys'=71 +'new'=94 +'null'=95 +'package'=59 +'return'=98 +'static'=46 +'strategy'=62 +'super'=49 +'switch'=88 +'synchronized'=101 +'targets'=63 +'throw'=97 +'true'=109 +'try'=99 +'typeof'=96 +'val'=44 +'var'=108 +'while'=92 +'{'=60 +'|'=107 +'||'=14 +'}'=61 +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__100=100 +T__101=101 +T__102=102 +T__103=103 +T__104=104 +T__105=105 +T__106=106 +T__107=107 +T__108=108 +T__109=109 +T__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 +T__89=89 +T__90=90 +T__91=91 +T__92=92 +T__93=93 +T__94=94 +T__95=95 +T__96=96 +T__97=97 +T__98=98 +T__99=99 diff --git a/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSLLexer.java b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSLLexer.java new file mode 100644 index 0000000..c80626a --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSLLexer.java @@ -0,0 +1,4519 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + */ +package org.eclipse.osbp.xtext.strategy.ui.contentassist.antlr.internal; + +// Hack: Use our own Lexer superclass by means of import. +// Currently there is no other way to specify the superclass for the lexer. +import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.Lexer; + + +import org.antlr.runtime.*; +import java.util.Stack; +import java.util.List; +import java.util.ArrayList; + +@SuppressWarnings("all") +public class InternalStrategyDSLLexer extends Lexer { + public static final int RULE_HEX=5; + public static final int T__50=50; + public static final int T__59=59; + public static final int T__55=55; + public static final int T__56=56; + public static final int T__57=57; + 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_INT=6; + public static final int T__66=66; + public static final int RULE_ML_COMMENT=9; + public static final int T__67=67; + public static final int T__68=68; + public static final int T__69=69; + public static final int T__62=62; + public static final int T__63=63; + public static final int T__64=64; + public static final int T__65=65; + public static final int T__37=37; + public static final int T__38=38; + public static final int T__39=39; + public static final int T__33=33; + public static final int T__34=34; + public static final int T__35=35; + public static final int T__36=36; + public static final int T__30=30; + public static final int T__31=31; + public static final int T__32=32; + 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__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__41=41; + public static final int T__42=42; + public static final int T__43=43; + public static final int T__91=91; + public static final int T__100=100; + public static final int T__92=92; + public static final int T__93=93; + public static final int T__102=102; + public static final int T__94=94; + public static final int T__101=101; + public static final int T__90=90; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__99=99; + public static final int T__13=13; + public static final int T__14=14; + public static final int T__95=95; + public static final int T__96=96; + public static final int T__97=97; + public static final int T__98=98; + public static final int RULE_DECIMAL=7; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int T__29=29; + public static final int T__22=22; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int T__70=70; + public static final int T__71=71; + public static final int T__72=72; + public static final int RULE_STRING=8; + public static final int RULE_SL_COMMENT=10; + public static final int T__77=77; + public static final int T__78=78; + public static final int T__79=79; + public static final int T__73=73; + public static final int EOF=-1; + public static final int T__74=74; + public static final int T__75=75; + public static final int T__76=76; + public static final int T__80=80; + public static final int T__81=81; + public static final int T__82=82; + public static final int T__83=83; + public static final int RULE_WS=11; + public static final int RULE_ANY_OTHER=12; + public static final int T__88=88; + public static final int T__108=108; + public static final int T__89=89; + public static final int T__107=107; + public static final int T__109=109; + public static final int T__84=84; + public static final int T__104=104; + public static final int T__85=85; + public static final int T__103=103; + public static final int T__86=86; + public static final int T__106=106; + public static final int T__87=87; + public static final int T__105=105; + + // delegates + // delegators + + public InternalStrategyDSLLexer() {;} + public InternalStrategyDSLLexer(CharStream input) { + this(input, new RecognizerSharedState()); + } + public InternalStrategyDSLLexer(CharStream input, RecognizerSharedState state) { + super(input,state); + + } + public String getGrammarFileName() { return "../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g"; } + + // $ANTLR start "T__13" + public final void mT__13() throws RecognitionException { + try { + int _type = T__13; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:11:7: ( '=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:12:7: ( '||' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:13:7: ( '&&' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:14:7: ( '+=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:15:7: ( '-=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:16:7: ( '*=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:17:7: ( '/=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:18:7: ( '%=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:19:7: ( '==' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:20:7: ( '!=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:21:7: ( '===' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:22:7: ( '!==' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23:7: ( '>=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:24:7: ( '>' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:25:7: ( '<' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:26:7: ( '->' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:27:7: ( '..<' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:28:7: ( '..' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:29:7: ( '=>' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:30:7: ( '<>' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:31:7: ( '?:' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:32:7: ( '+' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:33:7: ( '-' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:34:7: ( '*' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:35:7: ( '**' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:36:7: ( '/' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:37:7: ( '%' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:38:7: ( '!' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:39:7: ( '++' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:40:7: ( '--' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:41:7: ( '.' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:42:7: ( 'val' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:43:7: ( 'extends' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:44:7: ( 'static' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:45:7: ( 'import' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:46:7: ( 'extension' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:47:7: ( 'super' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:48:7: ( 'false' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:49:7: ( 'Horizontal' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:49:9: 'Horizontal' + { + match("Horizontal"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:50:7: ( 'Vertical' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:50:9: 'Vertical' + { + match("Vertical"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:51:7: ( 'Grid' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:51:9: 'Grid' + { + match("Grid"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:52:7: ( 'Form2' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:52:9: 'Form2' + { + match("Form2"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:53:7: ( 'Form3' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:53:9: 'Form3' + { + match("Form3"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:54:7: ( 'Css' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:54:9: 'Css' + { + match("Css"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:55:7: ( 'Forward' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:55:9: 'Forward' + { + match("Forward"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:56:7: ( 'Backward' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:56:9: 'Backward' + { + match("Backward"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:57:7: ( 'package' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:57:9: 'package' + { + match("package"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:58:7: ( '{' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:59:7: ( '}' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:60:7: ( 'strategy' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:60:9: 'strategy' + { + match("strategy"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:61:7: ( 'targets' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:61:9: 'targets' + { + match("targets"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:62:7: ( 'layoutingStrategy' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:62:9: 'layoutingStrategy' + { + match("layoutingStrategy"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:63:7: ( 'layout=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:63:9: 'layout=' + { + match("layout="); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:64:7: ( 'focusingStrategy' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:64:9: 'focusingStrategy' + { + match("focusingStrategy"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:65:7: ( 'ecviewFocusingId=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:65:9: 'ecviewFocusingId=' + { + match("ecviewFocusingId="); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:66:7: ( 'focus=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:66:9: 'focus=' + { + match("focus="); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:67:7: ( 'keyStrokeDefinition' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:67:9: 'keyStrokeDefinition' + { + match("keyStrokeDefinition"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:68:7: ( 'keyCode=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:68:9: 'keyCode=' + { + match("keyCode="); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:69:7: ( 'modifierKeys' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:69:9: 'modifierKeys' + { + match("modifierKeys"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:70:7: ( 'focusingEnhancer' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:70:9: 'focusingEnhancer' + { + match("focusingEnhancer"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:71:7: ( 'default' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:71:9: 'default' + { + match("default"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:72:7: ( 'defaultLayouting=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:72:9: 'defaultLayouting=' + { + match("defaultLayouting="); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:73:7: ( 'defaultFocusing=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:73:9: 'defaultFocusing=' + { + match("defaultFocusing="); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:74:7: ( '@' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:74:9: '@' + { + match('@'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__76" + + // $ANTLR start "T__77" + public final void mT__77() throws RecognitionException { + try { + int _type = T__77; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:75:7: ( '(' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:75:9: '(' + { + match('('); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__77" + + // $ANTLR start "T__78" + public final void mT__78() throws RecognitionException { + try { + int _type = T__78; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:76:7: ( ')' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:76:9: ')' + { + match(')'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__78" + + // $ANTLR start "T__79" + public final void mT__79() throws RecognitionException { + try { + int _type = T__79; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:77:7: ( ',' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:77:9: ',' + { + match(','); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__79" + + // $ANTLR start "T__80" + public final void mT__80() throws RecognitionException { + try { + int _type = T__80; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:78:7: ( ']' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:78:9: ']' + { + match(']'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__80" + + // $ANTLR start "T__81" + public final void mT__81() throws RecognitionException { + try { + int _type = T__81; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:79:7: ( '#' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:80:7: ( '[' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:81:7: ( 'instanceof' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:81:9: 'instanceof' + { + match("instanceof"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:82:7: ( 'as' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:82:9: 'as' + { + match("as"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:83:7: ( ';' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:84:7: ( 'if' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:84:9: 'if' + { + match("if"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:85:7: ( 'else' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:85:9: 'else' + { + match("else"); + + + } + + 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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:86:7: ( 'switch' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:86:9: 'switch' + { + match("switch"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__88" + + // $ANTLR start "T__89" + public final void mT__89() throws RecognitionException { + try { + int _type = T__89; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:87:7: ( ':' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:87:9: ':' + { + match(':'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__89" + + // $ANTLR start "T__90" + public final void mT__90() throws RecognitionException { + try { + int _type = T__90; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:88:7: ( 'case' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:88:9: 'case' + { + match("case"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__90" + + // $ANTLR start "T__91" + public final void mT__91() throws RecognitionException { + try { + int _type = T__91; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:89:7: ( 'for' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:89:9: 'for' + { + match("for"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__91" + + // $ANTLR start "T__92" + public final void mT__92() throws RecognitionException { + try { + int _type = T__92; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:90:7: ( 'while' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:90:9: 'while' + { + match("while"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__92" + + // $ANTLR start "T__93" + public final void mT__93() throws RecognitionException { + try { + int _type = T__93; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:91:7: ( 'do' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:91:9: 'do' + { + match("do"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__93" + + // $ANTLR start "T__94" + public final void mT__94() throws RecognitionException { + try { + int _type = T__94; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:92:7: ( 'new' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:92:9: 'new' + { + match("new"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__94" + + // $ANTLR start "T__95" + public final void mT__95() throws RecognitionException { + try { + int _type = T__95; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:93:7: ( 'null' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:93:9: 'null' + { + match("null"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__95" + + // $ANTLR start "T__96" + public final void mT__96() throws RecognitionException { + try { + int _type = T__96; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:94:7: ( 'typeof' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:94:9: 'typeof' + { + match("typeof"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__96" + + // $ANTLR start "T__97" + public final void mT__97() throws RecognitionException { + try { + int _type = T__97; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:95:7: ( 'throw' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:95:9: 'throw' + { + match("throw"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__97" + + // $ANTLR start "T__98" + public final void mT__98() throws RecognitionException { + try { + int _type = T__98; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:96:7: ( 'return' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:96:9: 'return' + { + match("return"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__98" + + // $ANTLR start "T__99" + public final void mT__99() throws RecognitionException { + try { + int _type = T__99; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:97:7: ( 'try' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:97:9: 'try' + { + match("try"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__99" + + // $ANTLR start "T__100" + public final void mT__100() throws RecognitionException { + try { + int _type = T__100; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:98:8: ( 'finally' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:98:10: 'finally' + { + match("finally"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__100" + + // $ANTLR start "T__101" + public final void mT__101() throws RecognitionException { + try { + int _type = T__101; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:99:8: ( 'synchronized' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:99:10: 'synchronized' + { + match("synchronized"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__101" + + // $ANTLR start "T__102" + public final void mT__102() throws RecognitionException { + try { + int _type = T__102; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:100:8: ( 'catch' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:100:10: 'catch' + { + match("catch"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__102" + + // $ANTLR start "T__103" + public final void mT__103() throws RecognitionException { + try { + int _type = T__103; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:101:8: ( '?' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:101:10: '?' + { + match('?'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__103" + + // $ANTLR start "T__104" + public final void mT__104() throws RecognitionException { + try { + int _type = T__104; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:102:8: ( '&' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:102:10: '&' + { + match('&'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__104" + + // $ANTLR start "T__105" + public final void mT__105() throws RecognitionException { + try { + int _type = T__105; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:103:8: ( '::' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:103:10: '::' + { + match("::"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__105" + + // $ANTLR start "T__106" + public final void mT__106() throws RecognitionException { + try { + int _type = T__106; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:104:8: ( '?.' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:104:10: '?.' + { + match("?."); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__106" + + // $ANTLR start "T__107" + public final void mT__107() throws RecognitionException { + try { + int _type = T__107; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:105:8: ( '|' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:105:10: '|' + { + match('|'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__107" + + // $ANTLR start "T__108" + public final void mT__108() throws RecognitionException { + try { + int _type = T__108; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:106:8: ( 'var' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:106:10: 'var' + { + match("var"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__108" + + // $ANTLR start "T__109" + public final void mT__109() throws RecognitionException { + try { + int _type = T__109; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:107:8: ( 'true' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:107:10: 'true' + { + match("true"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__109" + + // $ANTLR start "RULE_HEX" + public final void mRULE_HEX() throws RecognitionException { + try { + int _type = RULE_HEX; + int _channel = DEFAULT_TOKEN_CHANNEL; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23814:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23814:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23814: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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23814:13: '0x' + { + match("0x"); + + + } + break; + case 2 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23814:18: '0X' + { + match("0X"); + + + } + break; + + } + + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23814: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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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); + + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23814: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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23814:59: '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) + { + match('#'); + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23814: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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23814: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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23814: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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23816:10: ( '0' .. '9' ( '0' .. '9' | '_' )* ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23816:12: '0' .. '9' ( '0' .. '9' | '_' )* + { + matchRange('0','9'); + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23816: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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23818:14: ( RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23818:16: RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? + { + mRULE_INT(); + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23818: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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23818: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;} + + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23818:36: ( '+' | '-' )? + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='+'||LA6_0=='-') ) { + alt6=1; + } + switch (alt6) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + + } + + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23818: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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23818: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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23818: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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23820:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23820:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23820:11: ( '^' )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0=='^') ) { + alt9=1; + } + switch (alt9) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23820: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;} + + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23820: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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23822:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23822:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23822: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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23822:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? + { + match('\"'); + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23822: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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23822:21: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23822: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); + + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23822:44: ( '\"' )? + int alt12=2; + int LA12_0 = input.LA(1); + + if ( (LA12_0=='\"') ) { + alt12=1; + } + switch (alt12) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23822:44: '\"' + { + match('\"'); + + } + break; + + } + + + } + break; + case 2 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23822:49: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? + { + match('\''); + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23822: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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23822:55: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23822: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); + + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23822:79: ( '\\'' )? + int alt14=2; + int LA14_0 = input.LA(1); + + if ( (LA14_0=='\'') ) { + alt14=1; + } + switch (alt14) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23822: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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23824:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23824:19: '/*' ( options {greedy=false; } : . )* '*/' + { + match("/*"); + + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23824: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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23824: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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23826:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23826:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? + { + match("//"); + + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23826: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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23826: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); + + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23826: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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23826:41: ( '\\r' )? '\\n' + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23826:41: ( '\\r' )? + int alt18=2; + int LA18_0 = input.LA(1); + + if ( (LA18_0=='\r') ) { + alt18=1; + } + switch (alt18) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23826: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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23828:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23828:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23828: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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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; + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23830:16: ( . ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:23830:18: . + { + matchAny(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ANY_OTHER" + + public void mTokens() throws RecognitionException { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.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 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | T__105 | T__106 | T__107 | T__108 | T__109 | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt21=106; + alt21 = dfa21.predict(input); + switch (alt21) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:10: T__13 + { + mT__13(); + + } + break; + case 2 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:16: T__14 + { + mT__14(); + + } + break; + case 3 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:22: T__15 + { + mT__15(); + + } + break; + case 4 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:28: T__16 + { + mT__16(); + + } + break; + case 5 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:34: T__17 + { + mT__17(); + + } + break; + case 6 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:40: T__18 + { + mT__18(); + + } + break; + case 7 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:46: T__19 + { + mT__19(); + + } + break; + case 8 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:52: T__20 + { + mT__20(); + + } + break; + case 9 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:58: T__21 + { + mT__21(); + + } + break; + case 10 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:64: T__22 + { + mT__22(); + + } + break; + case 11 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:70: T__23 + { + mT__23(); + + } + break; + case 12 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:76: T__24 + { + mT__24(); + + } + break; + case 13 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:82: T__25 + { + mT__25(); + + } + break; + case 14 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:88: T__26 + { + mT__26(); + + } + break; + case 15 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:94: T__27 + { + mT__27(); + + } + break; + case 16 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:100: T__28 + { + mT__28(); + + } + break; + case 17 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:106: T__29 + { + mT__29(); + + } + break; + case 18 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:112: T__30 + { + mT__30(); + + } + break; + case 19 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:118: T__31 + { + mT__31(); + + } + break; + case 20 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:124: T__32 + { + mT__32(); + + } + break; + case 21 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:130: T__33 + { + mT__33(); + + } + break; + case 22 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:136: T__34 + { + mT__34(); + + } + break; + case 23 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:142: T__35 + { + mT__35(); + + } + break; + case 24 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:148: T__36 + { + mT__36(); + + } + break; + case 25 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:154: T__37 + { + mT__37(); + + } + break; + case 26 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:160: T__38 + { + mT__38(); + + } + break; + case 27 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:166: T__39 + { + mT__39(); + + } + break; + case 28 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:172: T__40 + { + mT__40(); + + } + break; + case 29 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:178: T__41 + { + mT__41(); + + } + break; + case 30 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:184: T__42 + { + mT__42(); + + } + break; + case 31 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:190: T__43 + { + mT__43(); + + } + break; + case 32 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:196: T__44 + { + mT__44(); + + } + break; + case 33 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:202: T__45 + { + mT__45(); + + } + break; + case 34 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:208: T__46 + { + mT__46(); + + } + break; + case 35 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:214: T__47 + { + mT__47(); + + } + break; + case 36 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:220: T__48 + { + mT__48(); + + } + break; + case 37 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:226: T__49 + { + mT__49(); + + } + break; + case 38 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:232: T__50 + { + mT__50(); + + } + break; + case 39 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:238: T__51 + { + mT__51(); + + } + break; + case 40 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:244: T__52 + { + mT__52(); + + } + break; + case 41 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:250: T__53 + { + mT__53(); + + } + break; + case 42 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:256: T__54 + { + mT__54(); + + } + break; + case 43 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:262: T__55 + { + mT__55(); + + } + break; + case 44 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:268: T__56 + { + mT__56(); + + } + break; + case 45 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:274: T__57 + { + mT__57(); + + } + break; + case 46 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:280: T__58 + { + mT__58(); + + } + break; + case 47 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:286: T__59 + { + mT__59(); + + } + break; + case 48 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:292: T__60 + { + mT__60(); + + } + break; + case 49 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:298: T__61 + { + mT__61(); + + } + break; + case 50 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:304: T__62 + { + mT__62(); + + } + break; + case 51 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:310: T__63 + { + mT__63(); + + } + break; + case 52 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:316: T__64 + { + mT__64(); + + } + break; + case 53 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:322: T__65 + { + mT__65(); + + } + break; + case 54 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:328: T__66 + { + mT__66(); + + } + break; + case 55 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:334: T__67 + { + mT__67(); + + } + break; + case 56 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:340: T__68 + { + mT__68(); + + } + break; + case 57 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:346: T__69 + { + mT__69(); + + } + break; + case 58 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:352: T__70 + { + mT__70(); + + } + break; + case 59 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:358: T__71 + { + mT__71(); + + } + break; + case 60 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:364: T__72 + { + mT__72(); + + } + break; + case 61 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:370: T__73 + { + mT__73(); + + } + break; + case 62 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:376: T__74 + { + mT__74(); + + } + break; + case 63 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:382: T__75 + { + mT__75(); + + } + break; + case 64 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:388: T__76 + { + mT__76(); + + } + break; + case 65 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:394: T__77 + { + mT__77(); + + } + break; + case 66 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:400: T__78 + { + mT__78(); + + } + break; + case 67 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:406: T__79 + { + mT__79(); + + } + break; + case 68 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:412: T__80 + { + mT__80(); + + } + break; + case 69 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:418: T__81 + { + mT__81(); + + } + break; + case 70 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:424: T__82 + { + mT__82(); + + } + break; + case 71 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:430: T__83 + { + mT__83(); + + } + break; + case 72 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:436: T__84 + { + mT__84(); + + } + break; + case 73 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:442: T__85 + { + mT__85(); + + } + break; + case 74 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:448: T__86 + { + mT__86(); + + } + break; + case 75 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:454: T__87 + { + mT__87(); + + } + break; + case 76 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:460: T__88 + { + mT__88(); + + } + break; + case 77 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:466: T__89 + { + mT__89(); + + } + break; + case 78 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:472: T__90 + { + mT__90(); + + } + break; + case 79 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:478: T__91 + { + mT__91(); + + } + break; + case 80 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:484: T__92 + { + mT__92(); + + } + break; + case 81 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:490: T__93 + { + mT__93(); + + } + break; + case 82 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:496: T__94 + { + mT__94(); + + } + break; + case 83 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:502: T__95 + { + mT__95(); + + } + break; + case 84 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:508: T__96 + { + mT__96(); + + } + break; + case 85 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:514: T__97 + { + mT__97(); + + } + break; + case 86 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:520: T__98 + { + mT__98(); + + } + break; + case 87 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:526: T__99 + { + mT__99(); + + } + break; + case 88 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:532: T__100 + { + mT__100(); + + } + break; + case 89 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:539: T__101 + { + mT__101(); + + } + break; + case 90 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:546: T__102 + { + mT__102(); + + } + break; + case 91 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:553: T__103 + { + mT__103(); + + } + break; + case 92 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:560: T__104 + { + mT__104(); + + } + break; + case 93 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:567: T__105 + { + mT__105(); + + } + break; + case 94 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:574: T__106 + { + mT__106(); + + } + break; + case 95 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:581: T__107 + { + mT__107(); + + } + break; + case 96 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:588: T__108 + { + mT__108(); + + } + break; + case 97 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:595: T__109 + { + mT__109(); + + } + break; + case 98 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:602: RULE_HEX + { + mRULE_HEX(); + + } + break; + case 99 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:611: RULE_INT + { + mRULE_INT(); + + } + break; + case 100 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:620: RULE_DECIMAL + { + mRULE_DECIMAL(); + + } + break; + case 101 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:633: RULE_ID + { + mRULE_ID(); + + } + break; + case 102 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:641: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 103 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:653: RULE_ML_COMMENT + { + mRULE_ML_COMMENT(); + + } + break; + case 104 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:669: RULE_SL_COMMENT + { + mRULE_SL_COMMENT(); + + } + break; + case 105 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:685: RULE_WS + { + mRULE_WS(); + + } + break; + case 106 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1:693: RULE_ANY_OTHER + { + mRULE_ANY_OTHER(); + + } + break; + + } + + } + + + protected DFA21 dfa21 = new DFA21(this); + static final String DFA21_eotS = + "\1\uffff\1\71\1\73\1\75\1\100\1\104\1\107\1\113\1\115\1\117\1\121"+ + "\1\123\1\125\1\130\14\132\2\uffff\5\132\7\uffff\1\132\1\uffff\1"+ + "\u0084\4\132\2\u008c\1\66\5\uffff\1\u0091\26\uffff\1\u0093\5\uffff"+ + "\1\u0095\4\uffff\1\132\1\uffff\11\132\1\u00a2\12\132\2\uffff\10"+ + "\132\1\u00b7\7\uffff\1\u00b8\3\uffff\5\132\1\uffff\1\u008c\12\uffff"+ + "\1\u00bf\1\u00c0\12\132\1\uffff\2\132\1\u00cd\5\132\1\u00d4\5\132"+ + "\1\u00da\5\132\2\uffff\3\132\1\u00e4\2\132\2\uffff\2\132\1\u00e9"+ + "\11\132\1\uffff\3\132\1\u00f6\2\132\1\uffff\5\132\1\uffff\1\u00ff"+ + "\5\132\1\u0105\2\132\1\uffff\1\u0108\3\132\1\uffff\2\132\1\u010f"+ + "\4\132\1\u0114\4\132\1\uffff\1\u011a\1\u011b\5\132\1\u0121\1\uffff"+ + "\5\132\1\uffff\1\u0127\1\u0128\1\uffff\4\132\1\u012d\1\132\1\uffff"+ + "\1\u012f\1\132\1\u0131\1\132\1\uffff\1\132\1\uffff\3\132\2\uffff"+ + "\4\132\1\u013b\1\uffff\5\132\2\uffff\1\u0142\1\u0143\2\132\1\uffff"+ + "\1\132\1\uffff\1\132\1\uffff\2\132\1\u014a\2\132\1\u014d\1\132\1"+ + "\u014f\1\u0150\1\uffff\1\132\1\uffff\3\132\1\u0157\2\uffff\2\132"+ + "\1\u015a\3\132\1\uffff\1\132\1\u0160\1\uffff\1\u0161\2\uffff\2\132"+ + "\1\uffff\3\132\1\uffff\1\u0167\1\132\1\uffff\5\132\2\uffff\5\132"+ + "\1\uffff\2\132\1\u0175\2\132\1\u0178\7\132\1\uffff\2\132\1\uffff"+ + "\6\132\1\u0188\4\132\1\u018d\3\132\1\uffff\4\132\1\uffff\21\132"+ + "\1\u01a6\1\u01a7\3\132\4\uffff\1\u01ab\1\132\2\uffff\1\132\1\u01ae"+ + "\1\uffff"; + static final String DFA21_eofS = + "\u01af\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\143"+ + "\1\164\1\146\1\141\1\157\1\145\1\162\1\157\1\163\2\141\2\uffff\2"+ + "\141\1\145\1\157\1\145\7\uffff\1\163\1\uffff\1\72\1\141\1\150\2"+ + "\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\166\1\163\1\141\1\160\1\151\1\156\1\160\1\163"+ + "\1\44\1\154\1\143\1\156\2\162\1\151\1\162\1\163\2\143\2\uffff\1"+ + "\162\1\160\1\162\1\165\2\171\1\144\1\146\1\44\7\uffff\1\44\3\uffff"+ + "\1\163\1\151\1\167\1\154\1\164\1\uffff\1\60\12\uffff\2\44\1\145"+ + "\1\151\1\145\1\164\1\141\1\145\1\164\1\143\1\157\1\164\1\uffff\1"+ + "\163\1\165\1\44\1\141\1\151\1\164\1\144\1\155\1\44\2\153\1\147\1"+ + "\145\1\157\1\44\1\145\1\157\1\103\1\151\1\141\2\uffff\1\145\1\143"+ + "\1\154\1\44\1\154\1\165\2\uffff\1\156\1\145\1\44\1\151\1\164\1\162"+ + "\1\143\1\150\1\162\1\141\1\145\1\163\1\uffff\1\154\1\172\1\151\1"+ + "\44\1\62\1\141\1\uffff\1\167\1\141\1\145\1\157\1\167\1\uffff\1\44"+ + "\1\165\1\164\1\157\1\146\1\165\1\44\1\150\1\145\1\uffff\1\44\1\162"+ + "\1\144\1\167\1\uffff\1\143\1\145\1\44\1\150\1\162\1\164\1\156\1"+ + "\44\1\75\1\154\1\157\1\143\1\uffff\2\44\1\162\1\141\1\147\1\164"+ + "\1\146\1\44\1\uffff\1\164\1\162\1\144\1\151\1\154\1\uffff\2\44\1"+ + "\uffff\1\156\1\163\1\151\1\106\1\44\1\147\1\uffff\1\44\1\157\1\44"+ + "\1\143\1\uffff\1\156\1\uffff\1\171\1\156\1\141\2\uffff\1\144\1\162"+ + "\1\145\1\163\1\44\1\uffff\1\75\1\157\2\145\1\164\2\uffff\2\44\2"+ + "\157\1\uffff\1\171\1\uffff\1\156\1\uffff\1\145\1\147\1\44\1\164"+ + "\1\154\1\44\1\144\2\44\1\uffff\1\156\1\uffff\1\153\1\75\1\162\1"+ + "\44\2\uffff\1\156\1\143\1\44\1\151\1\157\1\105\1\uffff\1\141\1\44"+ + "\1\uffff\1\44\2\uffff\1\147\1\145\1\uffff\1\113\1\141\1\157\1\uffff"+ + "\1\44\1\165\1\uffff\1\172\1\146\1\164\1\156\1\154\2\uffff\1\123"+ + "\1\104\1\145\1\171\1\143\1\uffff\1\163\1\145\1\44\1\162\1\150\1"+ + "\44\1\164\1\145\1\171\1\157\1\165\1\151\1\144\1\uffff\2\141\1\uffff"+ + "\1\162\1\146\1\163\1\165\1\163\1\156\1\44\1\164\1\156\1\141\1\151"+ + "\1\44\1\164\1\151\1\147\1\uffff\1\145\1\143\1\164\1\156\1\uffff"+ + "\1\151\1\156\1\111\1\147\2\145\1\151\1\156\1\147\1\144\1\171\1\162"+ + "\1\147\1\164\1\147\2\75\2\44\1\171\1\151\1\75\4\uffff\1\44\1\157"+ + "\2\uffff\1\156\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\2\157\1\145\1\162\1\157\1\163\2\141\2\uffff\1\171"+ + "\1\141\1\145\2\157\7\uffff\1\163\1\uffff\1\72\1\141\1\150\1\165"+ + "\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\166\1\163\1\162\1\160\1\151\1\156"+ + "\1\160\1\163\1\172\1\154\1\162\1\156\2\162\1\151\1\162\1\163\2\143"+ + "\2\uffff\1\162\1\160\1\162\3\171\1\144\1\146\1\172\7\uffff\1\172"+ + "\3\uffff\1\164\1\151\1\167\1\154\1\164\1\uffff\1\154\12\uffff\2"+ + "\172\1\145\1\151\1\145\1\164\1\141\1\145\1\164\1\143\1\157\1\164"+ + "\1\uffff\1\163\1\165\1\172\1\141\1\151\1\164\1\144\1\167\1\172\2"+ + "\153\1\147\1\145\1\157\1\172\1\145\1\157\1\123\1\151\1\141\2\uffff"+ + "\1\145\1\143\1\154\1\172\1\154\1\165\2\uffff\1\156\1\145\1\172\1"+ + "\151\1\164\1\162\1\143\1\150\1\162\1\141\1\145\1\163\1\uffff\1\154"+ + "\1\172\1\151\1\172\1\63\1\141\1\uffff\1\167\1\141\1\145\1\157\1"+ + "\167\1\uffff\1\172\1\165\1\164\1\157\1\146\1\165\1\172\1\150\1\145"+ + "\1\uffff\1\172\1\162\1\163\1\167\1\uffff\1\143\1\145\1\172\1\150"+ + "\1\162\1\164\1\156\1\172\1\151\1\154\1\157\1\143\1\uffff\2\172\1"+ + "\162\1\141\1\147\1\164\1\146\1\172\1\uffff\1\164\1\162\1\144\1\151"+ + "\1\154\1\uffff\2\172\1\uffff\1\156\1\163\1\151\1\106\1\172\1\147"+ + "\1\uffff\1\172\1\157\1\172\1\143\1\uffff\1\156\1\uffff\1\171\1\156"+ + "\1\141\2\uffff\1\144\1\162\1\145\1\163\1\172\1\uffff\1\151\1\157"+ + "\2\145\1\164\2\uffff\2\172\2\157\1\uffff\1\171\1\uffff\1\156\1\uffff"+ + "\1\145\1\147\1\172\1\164\1\154\1\172\1\144\2\172\1\uffff\1\156\1"+ + "\uffff\1\153\1\75\1\162\1\172\2\uffff\1\156\1\143\1\172\1\151\1"+ + "\157\1\123\1\uffff\1\141\1\172\1\uffff\1\172\2\uffff\1\147\1\145"+ + "\1\uffff\1\113\1\141\1\157\1\uffff\1\172\1\165\1\uffff\1\172\1\146"+ + "\1\164\1\156\1\154\2\uffff\1\123\1\104\1\145\1\171\1\143\1\uffff"+ + "\1\163\1\145\1\172\1\162\1\150\1\172\1\164\1\145\1\171\1\157\1\165"+ + "\1\151\1\144\1\uffff\2\141\1\uffff\1\162\1\146\1\163\1\165\1\163"+ + "\1\156\1\172\1\164\1\156\1\141\1\151\1\172\1\164\1\151\1\147\1\uffff"+ + "\1\145\1\143\1\164\1\156\1\uffff\1\151\1\156\1\111\1\147\2\145\1"+ + "\151\1\156\1\147\1\144\1\171\1\162\1\147\1\164\1\147\2\75\2\172"+ + "\1\171\1\151\1\75\4\uffff\1\172\1\157\2\uffff\1\156\1\172\1\uffff"; + static final String DFA21_acceptS = + "\32\uffff\1\60\1\61\5\uffff\1\100\1\101\1\102\1\103\1\104\1\105"+ + "\1\106\1\uffff\1\111\10\uffff\1\145\2\146\1\151\1\152\1\uffff\1"+ + "\23\1\1\1\2\1\137\1\3\1\134\1\4\1\35\1\26\1\5\1\20\1\36\1\27\1\6"+ + "\1\31\1\30\1\7\1\147\1\150\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\136\1\133\1\uffff\1\145\24\uffff"+ + "\1\60\1\61\11\uffff\1\100\1\101\1\102\1\103\1\104\1\105\1\106\1"+ + "\uffff\1\111\1\135\1\115\5\uffff\1\142\1\uffff\1\143\1\144\1\146"+ + "\1\151\1\13\1\11\1\14\1\12\1\21\1\22\14\uffff\1\112\24\uffff\1\121"+ + "\1\110\6\uffff\1\40\1\140\14\uffff\1\117\6\uffff\1\54\5\uffff\1"+ + "\127\11\uffff\1\122\4\uffff\1\113\14\uffff\1\51\10\uffff\1\141\5"+ + "\uffff\1\116\2\uffff\1\123\6\uffff\1\45\4\uffff\1\46\1\uffff\1\70"+ + "\3\uffff\1\52\1\53\5\uffff\1\125\5\uffff\1\132\1\120\4\uffff\1\42"+ + "\1\uffff\1\114\1\uffff\1\43\11\uffff\1\124\1\uffff\1\65\4\uffff"+ + "\1\126\1\41\6\uffff\1\130\2\uffff\1\55\1\uffff\1\57\1\63\2\uffff"+ + "\1\72\3\uffff\1\75\2\uffff\1\62\5\uffff\1\50\1\56\5\uffff\1\44\15"+ + "\uffff\1\107\2\uffff\1\47\17\uffff\1\131\4\uffff\1\73\26\uffff\1"+ + "\77\1\67\1\66\1\74\2\uffff\1\76\1\64\2\uffff\1\71"; + static final String DFA21_specialS = + "\1\0\u01ae\uffff}>"; + static final String[] DFA21_transitionS = { + "\11\66\2\65\2\66\1\65\22\66\1\65\1\11\1\63\1\46\1\62\1\10\1"+ + "\3\1\64\1\42\1\43\1\6\1\4\1\44\1\5\1\14\1\7\1\57\11\60\1\52"+ + "\1\51\1\13\1\1\1\12\1\15\1\41\1\62\1\30\1\27\2\62\1\26\1\25"+ + "\1\23\15\62\1\24\4\62\1\47\1\66\1\45\1\61\1\62\1\66\1\50\1\62"+ + "\1\53\1\40\1\17\1\22\2\62\1\21\1\62\1\36\1\35\1\37\1\55\1\62"+ + "\1\31\1\62\1\56\1\20\1\34\1\62\1\16\1\54\3\62\1\32\1\2\1\33"+ + "\uff82\66", + "\1\67\1\70", + "\1\72", + "\1\74", + "\1\77\21\uffff\1\76", + "\1\103\17\uffff\1\101\1\102", + "\1\106\22\uffff\1\105", + "\1\111\4\uffff\1\112\15\uffff\1\110", + "\1\114", + "\1\116", + "\1\120", + "\1\122", + "\1\124", + "\1\127\13\uffff\1\126", + "\1\131", + "\1\134\10\uffff\1\135\13\uffff\1\133", + "\1\136\1\137\1\uffff\1\140\1\uffff\1\141", + "\1\144\6\uffff\1\142\1\143", + "\1\145\7\uffff\1\147\5\uffff\1\146", + "\1\150", + "\1\151", + "\1\152", + "\1\153", + "\1\154", + "\1\155", + "\1\156", + "", + "", + "\1\161\6\uffff\1\163\11\uffff\1\164\6\uffff\1\162", + "\1\165", + "\1\166", + "\1\167", + "\1\170\11\uffff\1\171", + "", + "", + "", + "", + "", + "", + "", + "\1\u0081", + "", + "\1\u0083", + "\1\u0085", + "\1\u0086", + "\1\u0087\17\uffff\1\u0088", + "\1\u0089", + "\12\u008b\10\uffff\1\u008d\1\uffff\3\u008d\5\uffff\1\u008d"+ + "\13\uffff\1\u008a\6\uffff\1\u008b\2\uffff\1\u008d\1\uffff\3"+ + "\u008d\5\uffff\1\u008d\13\uffff\1\u008a", + "\12\u008b\10\uffff\1\u008d\1\uffff\3\u008d\5\uffff\1\u008d"+ + "\22\uffff\1\u008b\2\uffff\1\u008d\1\uffff\3\u008d\5\uffff\1"+ + "\u008d", + "\1\132\34\uffff\32\132\4\uffff\1\132\1\uffff\32\132", + "", + "", + "", + "", + "", + "\1\u0090", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\u0092", + "", + "", + "", + "", + "", + "\1\u0094", + "", + "", + "", + "", + "\1\u0096\5\uffff\1\u0097", + "", + "\1\u0098", + "\1\u0099", + "\1\u009a", + "\1\u009b\20\uffff\1\u009c", + "\1\u009d", + "\1\u009e", + "\1\u009f", + "\1\u00a0", + "\1\u00a1", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u00a3", + "\1\u00a4\16\uffff\1\u00a5", + "\1\u00a6", + "\1\u00a7", + "\1\u00a8", + "\1\u00a9", + "\1\u00aa", + "\1\u00ab", + "\1\u00ac", + "\1\u00ad", + "", + "", + "\1\u00ae", + "\1\u00af", + "\1\u00b0", + "\1\u00b2\3\uffff\1\u00b1", + "\1\u00b3", + "\1\u00b4", + "\1\u00b5", + "\1\u00b6", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "", + "", + "", + "", + "", + "", + "", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "", + "", + "", + "\1\u00b9\1\u00ba", + "\1\u00bb", + "\1\u00bc", + "\1\u00bd", + "\1\u00be", + "", + "\12\u008b\10\uffff\1\u008d\1\uffff\3\u008d\5\uffff\1\u008d"+ + "\22\uffff\1\u008b\2\uffff\1\u008d\1\uffff\3\u008d\5\uffff\1"+ + "\u008d", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u00c1", + "\1\u00c2", + "\1\u00c3", + "\1\u00c4", + "\1\u00c5", + "\1\u00c6", + "\1\u00c7", + "\1\u00c8", + "\1\u00c9", + "\1\u00ca", + "", + "\1\u00cb", + "\1\u00cc", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u00ce", + "\1\u00cf", + "\1\u00d0", + "\1\u00d1", + "\1\u00d2\11\uffff\1\u00d3", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u00d5", + "\1\u00d6", + "\1\u00d7", + "\1\u00d8", + "\1\u00d9", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u00db", + "\1\u00dc", + "\1\u00de\17\uffff\1\u00dd", + "\1\u00df", + "\1\u00e0", + "", + "", + "\1\u00e1", + "\1\u00e2", + "\1\u00e3", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u00e5", + "\1\u00e6", + "", + "", + "\1\u00e7", + "\1\u00e8", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u00ea", + "\1\u00eb", + "\1\u00ec", + "\1\u00ed", + "\1\u00ee", + "\1\u00ef", + "\1\u00f0", + "\1\u00f1", + "\1\u00f2", + "", + "\1\u00f3", + "\1\u00f4", + "\1\u00f5", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u00f7\1\u00f8", + "\1\u00f9", + "", + "\1\u00fa", + "\1\u00fb", + "\1\u00fc", + "\1\u00fd", + "\1\u00fe", + "", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u0100", + "\1\u0101", + "\1\u0102", + "\1\u0103", + "\1\u0104", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u0106", + "\1\u0107", + "", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u0109", + "\1\u010a\16\uffff\1\u010b", + "\1\u010c", + "", + "\1\u010d", + "\1\u010e", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u0110", + "\1\u0111", + "\1\u0112", + "\1\u0113", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u0116\53\uffff\1\u0115", + "\1\u0117", + "\1\u0118", + "\1\u0119", + "", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u011c", + "\1\u011d", + "\1\u011e", + "\1\u011f", + "\1\u0120", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "", + "\1\u0122", + "\1\u0123", + "\1\u0124", + "\1\u0125", + "\1\u0126", + "", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "", + "\1\u0129", + "\1\u012a", + "\1\u012b", + "\1\u012c", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u012e", + "", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u0130", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u0132", + "", + "\1\u0133", + "", + "\1\u0134", + "\1\u0135", + "\1\u0136", + "", + "", + "\1\u0137", + "\1\u0138", + "\1\u0139", + "\1\u013a", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "", + "\1\u013d\53\uffff\1\u013c", + "\1\u013e", + "\1\u013f", + "\1\u0140", + "\1\u0141", + "", + "", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u0144", + "\1\u0145", + "", + "\1\u0146", + "", + "\1\u0147", + "", + "\1\u0148", + "\1\u0149", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u014b", + "\1\u014c", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u014e", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "", + "\1\u0151", + "", + "\1\u0152", + "\1\u0153", + "\1\u0154", + "\1\132\13\uffff\12\132\7\uffff\5\132\1\u0156\5\132\1\u0155"+ + "\16\132\4\uffff\1\132\1\uffff\32\132", + "", + "", + "\1\u0158", + "\1\u0159", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u015b", + "\1\u015c", + "\1\u015e\15\uffff\1\u015d", + "", + "\1\u015f", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "", + "", + "\1\u0162", + "\1\u0163", + "", + "\1\u0164", + "\1\u0165", + "\1\u0166", + "", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u0168", + "", + "\1\u0169", + "\1\u016a", + "\1\u016b", + "\1\u016c", + "\1\u016d", + "", + "", + "\1\u016e", + "\1\u016f", + "\1\u0170", + "\1\u0171", + "\1\u0172", + "", + "\1\u0173", + "\1\u0174", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u0176", + "\1\u0177", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u0179", + "\1\u017a", + "\1\u017b", + "\1\u017c", + "\1\u017d", + "\1\u017e", + "\1\u017f", + "", + "\1\u0180", + "\1\u0181", + "", + "\1\u0182", + "\1\u0183", + "\1\u0184", + "\1\u0185", + "\1\u0186", + "\1\u0187", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u0189", + "\1\u018a", + "\1\u018b", + "\1\u018c", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u018e", + "\1\u018f", + "\1\u0190", + "", + "\1\u0191", + "\1\u0192", + "\1\u0193", + "\1\u0194", + "", + "\1\u0195", + "\1\u0196", + "\1\u0197", + "\1\u0198", + "\1\u0199", + "\1\u019a", + "\1\u019b", + "\1\u019c", + "\1\u019d", + "\1\u019e", + "\1\u019f", + "\1\u01a0", + "\1\u01a1", + "\1\u01a2", + "\1\u01a3", + "\1\u01a4", + "\1\u01a5", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u01a8", + "\1\u01a9", + "\1\u01aa", + "", + "", + "", + "", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "\1\u01ac", + "", + "", + "\1\u01ad", + "\1\132\13\uffff\12\132\7\uffff\32\132\4\uffff\1\132\1\uffff"+ + "\32\132", + "" + }; + + 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 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | T__105 | T__106 | T__107 | T__108 | T__109 | 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=='H') ) {s = 19;} + + else if ( (LA21_0=='V') ) {s = 20;} + + else if ( (LA21_0=='G') ) {s = 21;} + + else if ( (LA21_0=='F') ) {s = 22;} + + else if ( (LA21_0=='C') ) {s = 23;} + + else if ( (LA21_0=='B') ) {s = 24;} + + else if ( (LA21_0=='p') ) {s = 25;} + + else if ( (LA21_0=='{') ) {s = 26;} + + else if ( (LA21_0=='}') ) {s = 27;} + + else if ( (LA21_0=='t') ) {s = 28;} + + else if ( (LA21_0=='l') ) {s = 29;} + + else if ( (LA21_0=='k') ) {s = 30;} + + else if ( (LA21_0=='m') ) {s = 31;} + + else if ( (LA21_0=='d') ) {s = 32;} + + else if ( (LA21_0=='@') ) {s = 33;} + + else if ( (LA21_0=='(') ) {s = 34;} + + else if ( (LA21_0==')') ) {s = 35;} + + else if ( (LA21_0==',') ) {s = 36;} + + else if ( (LA21_0==']') ) {s = 37;} + + else if ( (LA21_0=='#') ) {s = 38;} + + else if ( (LA21_0=='[') ) {s = 39;} + + else if ( (LA21_0=='a') ) {s = 40;} + + else if ( (LA21_0==';') ) {s = 41;} + + else if ( (LA21_0==':') ) {s = 42;} + + else if ( (LA21_0=='c') ) {s = 43;} + + else if ( (LA21_0=='w') ) {s = 44;} + + else if ( (LA21_0=='n') ) {s = 45;} + + else if ( (LA21_0=='r') ) {s = 46;} + + else if ( (LA21_0=='0') ) {s = 47;} + + else if ( ((LA21_0>='1' && LA21_0<='9')) ) {s = 48;} + + else if ( (LA21_0=='^') ) {s = 49;} + + else if ( (LA21_0=='$'||LA21_0=='A'||(LA21_0>='D' && LA21_0<='E')||(LA21_0>='I' && LA21_0<='U')||(LA21_0>='W' && LA21_0<='Z')||LA21_0=='_'||LA21_0=='b'||(LA21_0>='g' && LA21_0<='h')||LA21_0=='j'||LA21_0=='o'||LA21_0=='q'||LA21_0=='u'||(LA21_0>='x' && LA21_0<='z')) ) {s = 50;} + + else if ( (LA21_0=='\"') ) {s = 51;} + + else if ( (LA21_0=='\'') ) {s = 52;} + + else if ( ((LA21_0>='\t' && LA21_0<='\n')||LA21_0=='\r'||LA21_0==' ') ) {s = 53;} + + 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 = 54;} + + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 21, _s, input); + error(nvae); + throw nvae; + } + } + + +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSLParser.java b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSLParser.java new file mode 100644 index 0000000..5e78627 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSLParser.java @@ -0,0 +1,10014 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + */ +package org.eclipse.osbp.xtext.strategy.ui.contentassist.antlr.internal; + +import java.io.InputStream; +import org.eclipse.xtext.*; +import org.eclipse.xtext.parser.*; +import org.eclipse.xtext.parser.impl.*; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; +import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; +import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; +import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.DFA; +import org.eclipse.osbp.xtext.strategy.services.StrategyDSLGrammarAccess; + + + +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 InternalStrategyDSLParser 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'", "'Horizontal'", "'Vertical'", "'Grid'", "'Form2'", "'Form3'", "'Css'", "'Forward'", "'Backward'", "'package'", "'{'", "'}'", "'strategy'", "'targets'", "'layoutingStrategy'", "'layout='", "'focusingStrategy'", "'ecviewFocusingId='", "'focus='", "'keyStrokeDefinition'", "'keyCode='", "'modifierKeys'", "'focusingEnhancer'", "'default'", "'defaultLayouting='", "'defaultFocusing='", "'@'", "'('", "')'", "','", "']'", "'#'", "'['", "'instanceof'", "'as'", "';'", "'if'", "'else'", "'switch'", "':'", "'case'", "'for'", "'while'", "'do'", "'new'", "'null'", "'typeof'", "'throw'", "'return'", "'try'", "'finally'", "'synchronized'", "'catch'", "'?'", "'&'", "'::'", "'?.'", "'|'", "'var'", "'true'" + }; + public static final int RULE_HEX=5; + public static final int T__50=50; + public static final int T__59=59; + public static final int T__55=55; + public static final int T__56=56; + public static final int T__57=57; + 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_INT=6; + public static final int T__66=66; + public static final int RULE_ML_COMMENT=9; + public static final int T__67=67; + public static final int T__68=68; + public static final int T__69=69; + public static final int T__62=62; + public static final int T__63=63; + public static final int T__64=64; + public static final int T__65=65; + public static final int T__37=37; + public static final int T__38=38; + public static final int T__39=39; + public static final int T__33=33; + public static final int T__34=34; + public static final int T__35=35; + public static final int T__36=36; + public static final int T__30=30; + public static final int T__31=31; + public static final int T__32=32; + 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__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__41=41; + public static final int T__42=42; + public static final int T__43=43; + public static final int T__91=91; + public static final int T__100=100; + public static final int T__92=92; + public static final int T__93=93; + public static final int T__102=102; + public static final int T__94=94; + public static final int T__101=101; + public static final int T__90=90; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__99=99; + public static final int T__13=13; + public static final int T__14=14; + public static final int T__95=95; + public static final int T__96=96; + public static final int T__97=97; + public static final int T__98=98; + public static final int RULE_DECIMAL=7; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int T__29=29; + public static final int T__22=22; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int T__70=70; + public static final int T__71=71; + public static final int T__72=72; + public static final int RULE_STRING=8; + public static final int RULE_SL_COMMENT=10; + public static final int T__77=77; + public static final int T__78=78; + public static final int T__79=79; + public static final int T__73=73; + public static final int EOF=-1; + public static final int T__74=74; + public static final int T__75=75; + public static final int T__76=76; + public static final int T__80=80; + public static final int T__81=81; + public static final int T__82=82; + public static final int T__83=83; + public static final int RULE_WS=11; + public static final int RULE_ANY_OTHER=12; + public static final int T__88=88; + public static final int T__108=108; + public static final int T__89=89; + public static final int T__107=107; + public static final int T__109=109; + public static final int T__84=84; + public static final int T__104=104; + public static final int T__85=85; + public static final int T__103=103; + public static final int T__86=86; + public static final int T__106=106; + public static final int T__87=87; + public static final int T__105=105; + + // delegates + // delegators + + + public InternalStrategyDSLParser(TokenStream input) { + this(input, new RecognizerSharedState()); + } + public InternalStrategyDSLParser(TokenStream input, RecognizerSharedState state) { + super(input, state); + + } + + + public String[] getTokenNames() { return InternalStrategyDSLParser.tokenNames; } + public String getGrammarFileName() { return "../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g"; } + + + + private StrategyDSLGrammarAccess grammarAccess; + + public void setGrammarAccess(StrategyDSLGrammarAccess grammarAccess) { + this.grammarAccess = grammarAccess; + } + + @Override + protected Grammar getGrammar() { + return grammarAccess.getGrammar(); + } + + @Override + protected String getValueForTokenName(String tokenName) { + return tokenName; + } + + + + + // $ANTLR start "entryRuleStrategyModel" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:61:1: entryRuleStrategyModel : ruleStrategyModel EOF ; + public final void entryRuleStrategyModel() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:62:1: ( ruleStrategyModel EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:63:1: ruleStrategyModel EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getStrategyModelRule()); + } + pushFollow(FOLLOW_ruleStrategyModel_in_entryRuleStrategyModel67); + ruleStrategyModel(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getStrategyModelRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleStrategyModel74); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleStrategyModel" + + + // $ANTLR start "ruleStrategyModel" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:70:1: ruleStrategyModel : ( ( rule__StrategyModel__PackagesAssignment )* ) ; + public final void ruleStrategyModel() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:74:2: ( ( ( rule__StrategyModel__PackagesAssignment )* ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:75:1: ( ( rule__StrategyModel__PackagesAssignment )* ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:75:1: ( ( rule__StrategyModel__PackagesAssignment )* ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:76:1: ( rule__StrategyModel__PackagesAssignment )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getStrategyModelAccess().getPackagesAssignment()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:77:1: ( rule__StrategyModel__PackagesAssignment )* + loop1: + do { + int alt1=2; + int LA1_0 = input.LA(1); + + if ( (LA1_0==59) ) { + alt1=1; + } + + + switch (alt1) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:77:2: rule__StrategyModel__PackagesAssignment + { + pushFollow(FOLLOW_rule__StrategyModel__PackagesAssignment_in_ruleStrategyModel100); + rule__StrategyModel__PackagesAssignment(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop1; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getStrategyModelAccess().getPackagesAssignment()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleStrategyModel" + + + // $ANTLR start "entryRuleStrategyPackage" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:89:1: entryRuleStrategyPackage : ruleStrategyPackage EOF ; + public final void entryRuleStrategyPackage() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:90:1: ( ruleStrategyPackage EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:91:1: ruleStrategyPackage EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getStrategyPackageRule()); + } + pushFollow(FOLLOW_ruleStrategyPackage_in_entryRuleStrategyPackage128); + ruleStrategyPackage(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getStrategyPackageRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleStrategyPackage135); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleStrategyPackage" + + + // $ANTLR start "ruleStrategyPackage" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:98:1: ruleStrategyPackage : ( ( rule__StrategyPackage__Group__0 ) ) ; + public final void ruleStrategyPackage() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:102:2: ( ( ( rule__StrategyPackage__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:103:1: ( ( rule__StrategyPackage__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:103:1: ( ( rule__StrategyPackage__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:104:1: ( rule__StrategyPackage__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getStrategyPackageAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:105:1: ( rule__StrategyPackage__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:105:2: rule__StrategyPackage__Group__0 + { + pushFollow(FOLLOW_rule__StrategyPackage__Group__0_in_ruleStrategyPackage161); + rule__StrategyPackage__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getStrategyPackageAccess().getGroup()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleStrategyPackage" + + + // $ANTLR start "entryRuleStrategyImport" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:117:1: entryRuleStrategyImport : ruleStrategyImport EOF ; + public final void entryRuleStrategyImport() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:118:1: ( ruleStrategyImport EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:119:1: ruleStrategyImport EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getStrategyImportRule()); + } + pushFollow(FOLLOW_ruleStrategyImport_in_entryRuleStrategyImport188); + ruleStrategyImport(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getStrategyImportRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleStrategyImport195); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleStrategyImport" + + + // $ANTLR start "ruleStrategyImport" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:126:1: ruleStrategyImport : ( ( rule__StrategyImport__Group__0 ) ) ; + public final void ruleStrategyImport() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:130:2: ( ( ( rule__StrategyImport__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:131:1: ( ( rule__StrategyImport__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:131:1: ( ( rule__StrategyImport__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:132:1: ( rule__StrategyImport__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getStrategyImportAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:133:1: ( rule__StrategyImport__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:133:2: rule__StrategyImport__Group__0 + { + pushFollow(FOLLOW_rule__StrategyImport__Group__0_in_ruleStrategyImport221); + rule__StrategyImport__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getStrategyImportAccess().getGroup()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleStrategyImport" + + + // $ANTLR start "entryRuleStrategyQualifiedNameWithWildCard" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:145:1: entryRuleStrategyQualifiedNameWithWildCard : ruleStrategyQualifiedNameWithWildCard EOF ; + public final void entryRuleStrategyQualifiedNameWithWildCard() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:146:1: ( ruleStrategyQualifiedNameWithWildCard EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:147:1: ruleStrategyQualifiedNameWithWildCard EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getStrategyQualifiedNameWithWildCardRule()); + } + pushFollow(FOLLOW_ruleStrategyQualifiedNameWithWildCard_in_entryRuleStrategyQualifiedNameWithWildCard248); + ruleStrategyQualifiedNameWithWildCard(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getStrategyQualifiedNameWithWildCardRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleStrategyQualifiedNameWithWildCard255); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleStrategyQualifiedNameWithWildCard" + + + // $ANTLR start "ruleStrategyQualifiedNameWithWildCard" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:154:1: ruleStrategyQualifiedNameWithWildCard : ( ( rule__StrategyQualifiedNameWithWildCard__Group__0 ) ) ; + public final void ruleStrategyQualifiedNameWithWildCard() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:158:2: ( ( ( rule__StrategyQualifiedNameWithWildCard__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:159:1: ( ( rule__StrategyQualifiedNameWithWildCard__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:159:1: ( ( rule__StrategyQualifiedNameWithWildCard__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:160:1: ( rule__StrategyQualifiedNameWithWildCard__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getStrategyQualifiedNameWithWildCardAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:161:1: ( rule__StrategyQualifiedNameWithWildCard__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:161:2: rule__StrategyQualifiedNameWithWildCard__Group__0 + { + pushFollow(FOLLOW_rule__StrategyQualifiedNameWithWildCard__Group__0_in_ruleStrategyQualifiedNameWithWildCard281); + rule__StrategyQualifiedNameWithWildCard__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getStrategyQualifiedNameWithWildCardAccess().getGroup()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleStrategyQualifiedNameWithWildCard" + + + // $ANTLR start "entryRuleStrategy" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:173:1: entryRuleStrategy : ruleStrategy EOF ; + public final void entryRuleStrategy() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:174:1: ( ruleStrategy EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:175:1: ruleStrategy EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getStrategyRule()); + } + pushFollow(FOLLOW_ruleStrategy_in_entryRuleStrategy308); + ruleStrategy(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getStrategyRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleStrategy315); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleStrategy" + + + // $ANTLR start "ruleStrategy" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:182:1: ruleStrategy : ( ( rule__Strategy__Group__0 ) ) ; + public final void ruleStrategy() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:186:2: ( ( ( rule__Strategy__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:187:1: ( ( rule__Strategy__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:187:1: ( ( rule__Strategy__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:188:1: ( rule__Strategy__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getStrategyAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:189:1: ( rule__Strategy__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:189:2: rule__Strategy__Group__0 + { + pushFollow(FOLLOW_rule__Strategy__Group__0_in_ruleStrategy341); + rule__Strategy__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getStrategyAccess().getGroup()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleStrategy" + + + // $ANTLR start "entryRuleStrategyTarget" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:201:1: entryRuleStrategyTarget : ruleStrategyTarget EOF ; + public final void entryRuleStrategyTarget() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:202:1: ( ruleStrategyTarget EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:203:1: ruleStrategyTarget EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getStrategyTargetRule()); + } + pushFollow(FOLLOW_ruleStrategyTarget_in_entryRuleStrategyTarget368); + ruleStrategyTarget(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getStrategyTargetRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleStrategyTarget375); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleStrategyTarget" + + + // $ANTLR start "ruleStrategyTarget" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:210:1: ruleStrategyTarget : ( ( rule__StrategyTarget__Group__0 ) ) ; + public final void ruleStrategyTarget() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:214:2: ( ( ( rule__StrategyTarget__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:215:1: ( ( rule__StrategyTarget__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:215:1: ( ( rule__StrategyTarget__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:216:1: ( rule__StrategyTarget__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getStrategyTargetAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:217:1: ( rule__StrategyTarget__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:217:2: rule__StrategyTarget__Group__0 + { + pushFollow(FOLLOW_rule__StrategyTarget__Group__0_in_ruleStrategyTarget401); + rule__StrategyTarget__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getStrategyTargetAccess().getGroup()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleStrategyTarget" + + + // $ANTLR start "entryRuleLayoutingStrategy" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:229:1: entryRuleLayoutingStrategy : ruleLayoutingStrategy EOF ; + public final void entryRuleLayoutingStrategy() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:230:1: ( ruleLayoutingStrategy EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:231:1: ruleLayoutingStrategy EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLayoutingStrategyRule()); + } + pushFollow(FOLLOW_ruleLayoutingStrategy_in_entryRuleLayoutingStrategy428); + ruleLayoutingStrategy(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLayoutingStrategyRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleLayoutingStrategy435); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleLayoutingStrategy" + + + // $ANTLR start "ruleLayoutingStrategy" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:238:1: ruleLayoutingStrategy : ( ( rule__LayoutingStrategy__Group__0 ) ) ; + public final void ruleLayoutingStrategy() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:242:2: ( ( ( rule__LayoutingStrategy__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:243:1: ( ( rule__LayoutingStrategy__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:243:1: ( ( rule__LayoutingStrategy__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:244:1: ( rule__LayoutingStrategy__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLayoutingStrategyAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:245:1: ( rule__LayoutingStrategy__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:245:2: rule__LayoutingStrategy__Group__0 + { + pushFollow(FOLLOW_rule__LayoutingStrategy__Group__0_in_ruleLayoutingStrategy461); + rule__LayoutingStrategy__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getLayoutingStrategyAccess().getGroup()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleLayoutingStrategy" + + + // $ANTLR start "entryRuleFocusingStrategy" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:257:1: entryRuleFocusingStrategy : ruleFocusingStrategy EOF ; + public final void entryRuleFocusingStrategy() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:258:1: ( ruleFocusingStrategy EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:259:1: ruleFocusingStrategy EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFocusingStrategyRule()); + } + pushFollow(FOLLOW_ruleFocusingStrategy_in_entryRuleFocusingStrategy488); + ruleFocusingStrategy(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFocusingStrategyRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleFocusingStrategy495); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleFocusingStrategy" + + + // $ANTLR start "ruleFocusingStrategy" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:266:1: ruleFocusingStrategy : ( ( rule__FocusingStrategy__Group__0 ) ) ; + public final void ruleFocusingStrategy() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:270:2: ( ( ( rule__FocusingStrategy__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:271:1: ( ( rule__FocusingStrategy__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:271:1: ( ( rule__FocusingStrategy__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:272:1: ( rule__FocusingStrategy__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFocusingStrategyAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:273:1: ( rule__FocusingStrategy__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:273:2: rule__FocusingStrategy__Group__0 + { + pushFollow(FOLLOW_rule__FocusingStrategy__Group__0_in_ruleFocusingStrategy521); + rule__FocusingStrategy__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getFocusingStrategyAccess().getGroup()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleFocusingStrategy" + + + // $ANTLR start "entryRuleFocusingEnhancer" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:285:1: entryRuleFocusingEnhancer : ruleFocusingEnhancer EOF ; + public final void entryRuleFocusingEnhancer() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:286:1: ( ruleFocusingEnhancer EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:287:1: ruleFocusingEnhancer EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFocusingEnhancerRule()); + } + pushFollow(FOLLOW_ruleFocusingEnhancer_in_entryRuleFocusingEnhancer548); + ruleFocusingEnhancer(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFocusingEnhancerRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleFocusingEnhancer555); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleFocusingEnhancer" + + + // $ANTLR start "ruleFocusingEnhancer" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:294:1: ruleFocusingEnhancer : ( ( rule__FocusingEnhancer__Group__0 ) ) ; + public final void ruleFocusingEnhancer() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:298:2: ( ( ( rule__FocusingEnhancer__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:299:1: ( ( rule__FocusingEnhancer__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:299:1: ( ( rule__FocusingEnhancer__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:300:1: ( rule__FocusingEnhancer__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFocusingEnhancerAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:301:1: ( rule__FocusingEnhancer__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:301:2: rule__FocusingEnhancer__Group__0 + { + pushFollow(FOLLOW_rule__FocusingEnhancer__Group__0_in_ruleFocusingEnhancer581); + rule__FocusingEnhancer__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getFocusingEnhancerAccess().getGroup()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleFocusingEnhancer" + + + // $ANTLR start "entryRuleStrategyDefault" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:313:1: entryRuleStrategyDefault : ruleStrategyDefault EOF ; + public final void entryRuleStrategyDefault() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:314:1: ( ruleStrategyDefault EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:315:1: ruleStrategyDefault EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getStrategyDefaultRule()); + } + pushFollow(FOLLOW_ruleStrategyDefault_in_entryRuleStrategyDefault608); + ruleStrategyDefault(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getStrategyDefaultRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleStrategyDefault615); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleStrategyDefault" + + + // $ANTLR start "ruleStrategyDefault" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:322:1: ruleStrategyDefault : ( ( rule__StrategyDefault__Group__0 ) ) ; + public final void ruleStrategyDefault() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:326:2: ( ( ( rule__StrategyDefault__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:327:1: ( ( rule__StrategyDefault__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:327:1: ( ( rule__StrategyDefault__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:328:1: ( rule__StrategyDefault__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getStrategyDefaultAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:329:1: ( rule__StrategyDefault__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:329:2: rule__StrategyDefault__Group__0 + { + pushFollow(FOLLOW_rule__StrategyDefault__Group__0_in_ruleStrategyDefault641); + rule__StrategyDefault__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getStrategyDefaultAccess().getGroup()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleStrategyDefault" + + + // $ANTLR start "entryRuleXAnnotation" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:341:1: entryRuleXAnnotation : ruleXAnnotation EOF ; + public final void entryRuleXAnnotation() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:342:1: ( ruleXAnnotation EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:343:1: ruleXAnnotation EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationRule()); + } + pushFollow(FOLLOW_ruleXAnnotation_in_entryRuleXAnnotation668); + ruleXAnnotation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAnnotationRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXAnnotation675); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXAnnotation" + + + // $ANTLR start "ruleXAnnotation" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:350:1: ruleXAnnotation : ( ( rule__XAnnotation__Group__0 ) ) ; + public final void ruleXAnnotation() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:354:2: ( ( ( rule__XAnnotation__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:355:1: ( ( rule__XAnnotation__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:355:1: ( ( rule__XAnnotation__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:356:1: ( rule__XAnnotation__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:357:1: ( rule__XAnnotation__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:357:2: rule__XAnnotation__Group__0 + { + pushFollow(FOLLOW_rule__XAnnotation__Group__0_in_ruleXAnnotation701); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:369:1: entryRuleXAnnotationElementValuePair : ruleXAnnotationElementValuePair EOF ; + public final void entryRuleXAnnotationElementValuePair() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:370:1: ( ruleXAnnotationElementValuePair EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:371:1: ruleXAnnotationElementValuePair EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationElementValuePairRule()); + } + pushFollow(FOLLOW_ruleXAnnotationElementValuePair_in_entryRuleXAnnotationElementValuePair728); + ruleXAnnotationElementValuePair(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAnnotationElementValuePairRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXAnnotationElementValuePair735); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXAnnotationElementValuePair" + + + // $ANTLR start "ruleXAnnotationElementValuePair" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:378:1: ruleXAnnotationElementValuePair : ( ( rule__XAnnotationElementValuePair__Group__0 ) ) ; + public final void ruleXAnnotationElementValuePair() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:382:2: ( ( ( rule__XAnnotationElementValuePair__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:383:1: ( ( rule__XAnnotationElementValuePair__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:383:1: ( ( rule__XAnnotationElementValuePair__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:384:1: ( rule__XAnnotationElementValuePair__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationElementValuePairAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:385:1: ( rule__XAnnotationElementValuePair__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:385:2: rule__XAnnotationElementValuePair__Group__0 + { + pushFollow(FOLLOW_rule__XAnnotationElementValuePair__Group__0_in_ruleXAnnotationElementValuePair761); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:397:1: entryRuleXAnnotationElementValueOrCommaList : ruleXAnnotationElementValueOrCommaList EOF ; + public final void entryRuleXAnnotationElementValueOrCommaList() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:398:1: ( ruleXAnnotationElementValueOrCommaList EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:399:1: ruleXAnnotationElementValueOrCommaList EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationElementValueOrCommaListRule()); + } + pushFollow(FOLLOW_ruleXAnnotationElementValueOrCommaList_in_entryRuleXAnnotationElementValueOrCommaList788); + ruleXAnnotationElementValueOrCommaList(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAnnotationElementValueOrCommaListRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXAnnotationElementValueOrCommaList795); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXAnnotationElementValueOrCommaList" + + + // $ANTLR start "ruleXAnnotationElementValueOrCommaList" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:406:1: ruleXAnnotationElementValueOrCommaList : ( ( rule__XAnnotationElementValueOrCommaList__Alternatives ) ) ; + public final void ruleXAnnotationElementValueOrCommaList() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:410:2: ( ( ( rule__XAnnotationElementValueOrCommaList__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:411:1: ( ( rule__XAnnotationElementValueOrCommaList__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:411:1: ( ( rule__XAnnotationElementValueOrCommaList__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:412:1: ( rule__XAnnotationElementValueOrCommaList__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:413:1: ( rule__XAnnotationElementValueOrCommaList__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:413:2: rule__XAnnotationElementValueOrCommaList__Alternatives + { + pushFollow(FOLLOW_rule__XAnnotationElementValueOrCommaList__Alternatives_in_ruleXAnnotationElementValueOrCommaList821); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:425:1: entryRuleXAnnotationElementValue : ruleXAnnotationElementValue EOF ; + public final void entryRuleXAnnotationElementValue() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:426:1: ( ruleXAnnotationElementValue EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:427:1: ruleXAnnotationElementValue EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationElementValueRule()); + } + pushFollow(FOLLOW_ruleXAnnotationElementValue_in_entryRuleXAnnotationElementValue848); + ruleXAnnotationElementValue(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAnnotationElementValueRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXAnnotationElementValue855); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXAnnotationElementValue" + + + // $ANTLR start "ruleXAnnotationElementValue" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:434:1: ruleXAnnotationElementValue : ( ( rule__XAnnotationElementValue__Alternatives ) ) ; + public final void ruleXAnnotationElementValue() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:438:2: ( ( ( rule__XAnnotationElementValue__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:439:1: ( ( rule__XAnnotationElementValue__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:439:1: ( ( rule__XAnnotationElementValue__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:440:1: ( rule__XAnnotationElementValue__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationElementValueAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:441:1: ( rule__XAnnotationElementValue__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:441:2: rule__XAnnotationElementValue__Alternatives + { + pushFollow(FOLLOW_rule__XAnnotationElementValue__Alternatives_in_ruleXAnnotationElementValue881); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:453:1: entryRuleXAnnotationOrExpression : ruleXAnnotationOrExpression EOF ; + public final void entryRuleXAnnotationOrExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:454:1: ( ruleXAnnotationOrExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:455:1: ruleXAnnotationOrExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationOrExpressionRule()); + } + pushFollow(FOLLOW_ruleXAnnotationOrExpression_in_entryRuleXAnnotationOrExpression908); + ruleXAnnotationOrExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAnnotationOrExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXAnnotationOrExpression915); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXAnnotationOrExpression" + + + // $ANTLR start "ruleXAnnotationOrExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:462:1: ruleXAnnotationOrExpression : ( ( rule__XAnnotationOrExpression__Alternatives ) ) ; + public final void ruleXAnnotationOrExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:466:2: ( ( ( rule__XAnnotationOrExpression__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:467:1: ( ( rule__XAnnotationOrExpression__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:467:1: ( ( rule__XAnnotationOrExpression__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:468:1: ( rule__XAnnotationOrExpression__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationOrExpressionAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:469:1: ( rule__XAnnotationOrExpression__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:469:2: rule__XAnnotationOrExpression__Alternatives + { + pushFollow(FOLLOW_rule__XAnnotationOrExpression__Alternatives_in_ruleXAnnotationOrExpression941); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:481:1: entryRuleXExpression : ruleXExpression EOF ; + public final void entryRuleXExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:482:1: ( ruleXExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:483:1: ruleXExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionRule()); + } + pushFollow(FOLLOW_ruleXExpression_in_entryRuleXExpression968); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXExpression975); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXExpression" + + + // $ANTLR start "ruleXExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:490:1: ruleXExpression : ( ruleXAssignment ) ; + public final void ruleXExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:494:2: ( ( ruleXAssignment ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:495:1: ( ruleXAssignment ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:495:1: ( ruleXAssignment ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:496:1: ruleXAssignment + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); + } + pushFollow(FOLLOW_ruleXAssignment_in_ruleXExpression1001); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:509:1: entryRuleXAssignment : ruleXAssignment EOF ; + public final void entryRuleXAssignment() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:510:1: ( ruleXAssignment EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:511:1: ruleXAssignment EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentRule()); + } + pushFollow(FOLLOW_ruleXAssignment_in_entryRuleXAssignment1027); + ruleXAssignment(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXAssignment1034); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXAssignment" + + + // $ANTLR start "ruleXAssignment" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:518:1: ruleXAssignment : ( ( rule__XAssignment__Alternatives ) ) ; + public final void ruleXAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:522:2: ( ( ( rule__XAssignment__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:523:1: ( ( rule__XAssignment__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:523:1: ( ( rule__XAssignment__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:524:1: ( rule__XAssignment__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:525:1: ( rule__XAssignment__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:525:2: rule__XAssignment__Alternatives + { + pushFollow(FOLLOW_rule__XAssignment__Alternatives_in_ruleXAssignment1060); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:537:1: entryRuleOpSingleAssign : ruleOpSingleAssign EOF ; + public final void entryRuleOpSingleAssign() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:538:1: ( ruleOpSingleAssign EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:539:1: ruleOpSingleAssign EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpSingleAssignRule()); + } + pushFollow(FOLLOW_ruleOpSingleAssign_in_entryRuleOpSingleAssign1087); + ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpSingleAssignRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleOpSingleAssign1094); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpSingleAssign" + + + // $ANTLR start "ruleOpSingleAssign" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:546:1: ruleOpSingleAssign : ( '=' ) ; + public final void ruleOpSingleAssign() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:550:2: ( ( '=' ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:551:1: ( '=' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:551:1: ( '=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:552:1: '=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); + } + match(input,13,FOLLOW_13_in_ruleOpSingleAssign1121); 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:567:1: entryRuleOpMultiAssign : ruleOpMultiAssign EOF ; + public final void entryRuleOpMultiAssign() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:568:1: ( ruleOpMultiAssign EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:569:1: ruleOpMultiAssign EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignRule()); + } + pushFollow(FOLLOW_ruleOpMultiAssign_in_entryRuleOpMultiAssign1149); + ruleOpMultiAssign(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleOpMultiAssign1156); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpMultiAssign" + + + // $ANTLR start "ruleOpMultiAssign" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:576:1: ruleOpMultiAssign : ( ( rule__OpMultiAssign__Alternatives ) ) ; + public final void ruleOpMultiAssign() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:580:2: ( ( ( rule__OpMultiAssign__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:581:1: ( ( rule__OpMultiAssign__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:581:1: ( ( rule__OpMultiAssign__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:582:1: ( rule__OpMultiAssign__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:583:1: ( rule__OpMultiAssign__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:583:2: rule__OpMultiAssign__Alternatives + { + pushFollow(FOLLOW_rule__OpMultiAssign__Alternatives_in_ruleOpMultiAssign1182); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:595:1: entryRuleXOrExpression : ruleXOrExpression EOF ; + public final void entryRuleXOrExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:596:1: ( ruleXOrExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:597:1: ruleXOrExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionRule()); + } + pushFollow(FOLLOW_ruleXOrExpression_in_entryRuleXOrExpression1209); + ruleXOrExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXOrExpression1216); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXOrExpression" + + + // $ANTLR start "ruleXOrExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:604:1: ruleXOrExpression : ( ( rule__XOrExpression__Group__0 ) ) ; + public final void ruleXOrExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:608:2: ( ( ( rule__XOrExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:609:1: ( ( rule__XOrExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:609:1: ( ( rule__XOrExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:610:1: ( rule__XOrExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:611:1: ( rule__XOrExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:611:2: rule__XOrExpression__Group__0 + { + pushFollow(FOLLOW_rule__XOrExpression__Group__0_in_ruleXOrExpression1242); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:623:1: entryRuleOpOr : ruleOpOr EOF ; + public final void entryRuleOpOr() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:624:1: ( ruleOpOr EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:625:1: ruleOpOr EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOrRule()); + } + pushFollow(FOLLOW_ruleOpOr_in_entryRuleOpOr1269); + ruleOpOr(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOrRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleOpOr1276); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpOr" + + + // $ANTLR start "ruleOpOr" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:632:1: ruleOpOr : ( '||' ) ; + public final void ruleOpOr() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:636:2: ( ( '||' ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:637:1: ( '||' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:637:1: ( '||' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:638:1: '||' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); + } + match(input,14,FOLLOW_14_in_ruleOpOr1303); 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:653:1: entryRuleXAndExpression : ruleXAndExpression EOF ; + public final void entryRuleXAndExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:654:1: ( ruleXAndExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:655:1: ruleXAndExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionRule()); + } + pushFollow(FOLLOW_ruleXAndExpression_in_entryRuleXAndExpression1331); + ruleXAndExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXAndExpression1338); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXAndExpression" + + + // $ANTLR start "ruleXAndExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:662:1: ruleXAndExpression : ( ( rule__XAndExpression__Group__0 ) ) ; + public final void ruleXAndExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:666:2: ( ( ( rule__XAndExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:667:1: ( ( rule__XAndExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:667:1: ( ( rule__XAndExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:668:1: ( rule__XAndExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:669:1: ( rule__XAndExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:669:2: rule__XAndExpression__Group__0 + { + pushFollow(FOLLOW_rule__XAndExpression__Group__0_in_ruleXAndExpression1364); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:681:1: entryRuleOpAnd : ruleOpAnd EOF ; + public final void entryRuleOpAnd() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:682:1: ( ruleOpAnd EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:683:1: ruleOpAnd EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAndRule()); + } + pushFollow(FOLLOW_ruleOpAnd_in_entryRuleOpAnd1391); + ruleOpAnd(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAndRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleOpAnd1398); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpAnd" + + + // $ANTLR start "ruleOpAnd" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:690:1: ruleOpAnd : ( '&&' ) ; + public final void ruleOpAnd() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:694:2: ( ( '&&' ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:695:1: ( '&&' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:695:1: ( '&&' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:696:1: '&&' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); + } + match(input,15,FOLLOW_15_in_ruleOpAnd1425); 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:711:1: entryRuleXEqualityExpression : ruleXEqualityExpression EOF ; + public final void entryRuleXEqualityExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:712:1: ( ruleXEqualityExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:713:1: ruleXEqualityExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionRule()); + } + pushFollow(FOLLOW_ruleXEqualityExpression_in_entryRuleXEqualityExpression1453); + ruleXEqualityExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXEqualityExpression1460); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXEqualityExpression" + + + // $ANTLR start "ruleXEqualityExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:720:1: ruleXEqualityExpression : ( ( rule__XEqualityExpression__Group__0 ) ) ; + public final void ruleXEqualityExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:724:2: ( ( ( rule__XEqualityExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:725:1: ( ( rule__XEqualityExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:725:1: ( ( rule__XEqualityExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:726:1: ( rule__XEqualityExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:727:1: ( rule__XEqualityExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:727:2: rule__XEqualityExpression__Group__0 + { + pushFollow(FOLLOW_rule__XEqualityExpression__Group__0_in_ruleXEqualityExpression1486); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:739:1: entryRuleOpEquality : ruleOpEquality EOF ; + public final void entryRuleOpEquality() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:740:1: ( ruleOpEquality EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:741:1: ruleOpEquality EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityRule()); + } + pushFollow(FOLLOW_ruleOpEquality_in_entryRuleOpEquality1513); + ruleOpEquality(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleOpEquality1520); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpEquality" + + + // $ANTLR start "ruleOpEquality" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:748:1: ruleOpEquality : ( ( rule__OpEquality__Alternatives ) ) ; + public final void ruleOpEquality() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:752:2: ( ( ( rule__OpEquality__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:753:1: ( ( rule__OpEquality__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:753:1: ( ( rule__OpEquality__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:754:1: ( rule__OpEquality__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:755:1: ( rule__OpEquality__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:755:2: rule__OpEquality__Alternatives + { + pushFollow(FOLLOW_rule__OpEquality__Alternatives_in_ruleOpEquality1546); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:767:1: entryRuleXRelationalExpression : ruleXRelationalExpression EOF ; + public final void entryRuleXRelationalExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:768:1: ( ruleXRelationalExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:769:1: ruleXRelationalExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionRule()); + } + pushFollow(FOLLOW_ruleXRelationalExpression_in_entryRuleXRelationalExpression1573); + ruleXRelationalExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXRelationalExpression1580); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXRelationalExpression" + + + // $ANTLR start "ruleXRelationalExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:776:1: ruleXRelationalExpression : ( ( rule__XRelationalExpression__Group__0 ) ) ; + public final void ruleXRelationalExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:780:2: ( ( ( rule__XRelationalExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:781:1: ( ( rule__XRelationalExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:781:1: ( ( rule__XRelationalExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:782:1: ( rule__XRelationalExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:783:1: ( rule__XRelationalExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:783:2: rule__XRelationalExpression__Group__0 + { + pushFollow(FOLLOW_rule__XRelationalExpression__Group__0_in_ruleXRelationalExpression1606); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:795:1: entryRuleOpCompare : ruleOpCompare EOF ; + public final void entryRuleOpCompare() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:796:1: ( ruleOpCompare EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:797:1: ruleOpCompare EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareRule()); + } + pushFollow(FOLLOW_ruleOpCompare_in_entryRuleOpCompare1633); + ruleOpCompare(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleOpCompare1640); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpCompare" + + + // $ANTLR start "ruleOpCompare" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:804:1: ruleOpCompare : ( ( rule__OpCompare__Alternatives ) ) ; + public final void ruleOpCompare() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:808:2: ( ( ( rule__OpCompare__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:809:1: ( ( rule__OpCompare__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:809:1: ( ( rule__OpCompare__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:810:1: ( rule__OpCompare__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:811:1: ( rule__OpCompare__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:811:2: rule__OpCompare__Alternatives + { + pushFollow(FOLLOW_rule__OpCompare__Alternatives_in_ruleOpCompare1666); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:823:1: entryRuleXOtherOperatorExpression : ruleXOtherOperatorExpression EOF ; + public final void entryRuleXOtherOperatorExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:824:1: ( ruleXOtherOperatorExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:825:1: ruleXOtherOperatorExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionRule()); + } + pushFollow(FOLLOW_ruleXOtherOperatorExpression_in_entryRuleXOtherOperatorExpression1693); + ruleXOtherOperatorExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXOtherOperatorExpression1700); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXOtherOperatorExpression" + + + // $ANTLR start "ruleXOtherOperatorExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:832:1: ruleXOtherOperatorExpression : ( ( rule__XOtherOperatorExpression__Group__0 ) ) ; + public final void ruleXOtherOperatorExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:836:2: ( ( ( rule__XOtherOperatorExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:837:1: ( ( rule__XOtherOperatorExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:837:1: ( ( rule__XOtherOperatorExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:838:1: ( rule__XOtherOperatorExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:839:1: ( rule__XOtherOperatorExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:839:2: rule__XOtherOperatorExpression__Group__0 + { + pushFollow(FOLLOW_rule__XOtherOperatorExpression__Group__0_in_ruleXOtherOperatorExpression1726); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:851:1: entryRuleOpOther : ruleOpOther EOF ; + public final void entryRuleOpOther() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:852:1: ( ruleOpOther EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:853:1: ruleOpOther EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherRule()); + } + pushFollow(FOLLOW_ruleOpOther_in_entryRuleOpOther1753); + ruleOpOther(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleOpOther1760); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpOther" + + + // $ANTLR start "ruleOpOther" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:860:1: ruleOpOther : ( ( rule__OpOther__Alternatives ) ) ; + public final void ruleOpOther() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:864:2: ( ( ( rule__OpOther__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:865:1: ( ( rule__OpOther__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:865:1: ( ( rule__OpOther__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:866:1: ( rule__OpOther__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:867:1: ( rule__OpOther__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:867:2: rule__OpOther__Alternatives + { + pushFollow(FOLLOW_rule__OpOther__Alternatives_in_ruleOpOther1786); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:879:1: entryRuleXAdditiveExpression : ruleXAdditiveExpression EOF ; + public final void entryRuleXAdditiveExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:880:1: ( ruleXAdditiveExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:881:1: ruleXAdditiveExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionRule()); + } + pushFollow(FOLLOW_ruleXAdditiveExpression_in_entryRuleXAdditiveExpression1813); + ruleXAdditiveExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXAdditiveExpression1820); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXAdditiveExpression" + + + // $ANTLR start "ruleXAdditiveExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:888:1: ruleXAdditiveExpression : ( ( rule__XAdditiveExpression__Group__0 ) ) ; + public final void ruleXAdditiveExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:892:2: ( ( ( rule__XAdditiveExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:893:1: ( ( rule__XAdditiveExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:893:1: ( ( rule__XAdditiveExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:894:1: ( rule__XAdditiveExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:895:1: ( rule__XAdditiveExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:895:2: rule__XAdditiveExpression__Group__0 + { + pushFollow(FOLLOW_rule__XAdditiveExpression__Group__0_in_ruleXAdditiveExpression1846); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:907:1: entryRuleOpAdd : ruleOpAdd EOF ; + public final void entryRuleOpAdd() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:908:1: ( ruleOpAdd EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:909:1: ruleOpAdd EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAddRule()); + } + pushFollow(FOLLOW_ruleOpAdd_in_entryRuleOpAdd1873); + ruleOpAdd(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAddRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleOpAdd1880); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpAdd" + + + // $ANTLR start "ruleOpAdd" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:916:1: ruleOpAdd : ( ( rule__OpAdd__Alternatives ) ) ; + public final void ruleOpAdd() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:920:2: ( ( ( rule__OpAdd__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:921:1: ( ( rule__OpAdd__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:921:1: ( ( rule__OpAdd__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:922:1: ( rule__OpAdd__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAddAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:923:1: ( rule__OpAdd__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:923:2: rule__OpAdd__Alternatives + { + pushFollow(FOLLOW_rule__OpAdd__Alternatives_in_ruleOpAdd1906); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:935:1: entryRuleXMultiplicativeExpression : ruleXMultiplicativeExpression EOF ; + public final void entryRuleXMultiplicativeExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:936:1: ( ruleXMultiplicativeExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:937:1: ruleXMultiplicativeExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionRule()); + } + pushFollow(FOLLOW_ruleXMultiplicativeExpression_in_entryRuleXMultiplicativeExpression1933); + ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXMultiplicativeExpression1940); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXMultiplicativeExpression" + + + // $ANTLR start "ruleXMultiplicativeExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:944:1: ruleXMultiplicativeExpression : ( ( rule__XMultiplicativeExpression__Group__0 ) ) ; + public final void ruleXMultiplicativeExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:948:2: ( ( ( rule__XMultiplicativeExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:949:1: ( ( rule__XMultiplicativeExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:949:1: ( ( rule__XMultiplicativeExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:950:1: ( rule__XMultiplicativeExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:951:1: ( rule__XMultiplicativeExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:951:2: rule__XMultiplicativeExpression__Group__0 + { + pushFollow(FOLLOW_rule__XMultiplicativeExpression__Group__0_in_ruleXMultiplicativeExpression1966); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:963:1: entryRuleOpMulti : ruleOpMulti EOF ; + public final void entryRuleOpMulti() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:964:1: ( ruleOpMulti EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:965:1: ruleOpMulti EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiRule()); + } + pushFollow(FOLLOW_ruleOpMulti_in_entryRuleOpMulti1993); + ruleOpMulti(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleOpMulti2000); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpMulti" + + + // $ANTLR start "ruleOpMulti" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:972:1: ruleOpMulti : ( ( rule__OpMulti__Alternatives ) ) ; + public final void ruleOpMulti() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:976:2: ( ( ( rule__OpMulti__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:977:1: ( ( rule__OpMulti__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:977:1: ( ( rule__OpMulti__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:978:1: ( rule__OpMulti__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:979:1: ( rule__OpMulti__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:979:2: rule__OpMulti__Alternatives + { + pushFollow(FOLLOW_rule__OpMulti__Alternatives_in_ruleOpMulti2026); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:991:1: entryRuleXUnaryOperation : ruleXUnaryOperation EOF ; + public final void entryRuleXUnaryOperation() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:992:1: ( ruleXUnaryOperation EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:993:1: ruleXUnaryOperation EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationRule()); + } + pushFollow(FOLLOW_ruleXUnaryOperation_in_entryRuleXUnaryOperation2053); + ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXUnaryOperation2060); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXUnaryOperation" + + + // $ANTLR start "ruleXUnaryOperation" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1000:1: ruleXUnaryOperation : ( ( rule__XUnaryOperation__Alternatives ) ) ; + public final void ruleXUnaryOperation() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1004:2: ( ( ( rule__XUnaryOperation__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1005:1: ( ( rule__XUnaryOperation__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1005:1: ( ( rule__XUnaryOperation__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1006:1: ( rule__XUnaryOperation__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1007:1: ( rule__XUnaryOperation__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1007:2: rule__XUnaryOperation__Alternatives + { + pushFollow(FOLLOW_rule__XUnaryOperation__Alternatives_in_ruleXUnaryOperation2086); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1019:1: entryRuleOpUnary : ruleOpUnary EOF ; + public final void entryRuleOpUnary() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1020:1: ( ruleOpUnary EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1021:1: ruleOpUnary EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryRule()); + } + pushFollow(FOLLOW_ruleOpUnary_in_entryRuleOpUnary2113); + ruleOpUnary(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleOpUnary2120); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpUnary" + + + // $ANTLR start "ruleOpUnary" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1028:1: ruleOpUnary : ( ( rule__OpUnary__Alternatives ) ) ; + public final void ruleOpUnary() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1032:2: ( ( ( rule__OpUnary__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1033:1: ( ( rule__OpUnary__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1033:1: ( ( rule__OpUnary__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1034:1: ( rule__OpUnary__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1035:1: ( rule__OpUnary__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1035:2: rule__OpUnary__Alternatives + { + pushFollow(FOLLOW_rule__OpUnary__Alternatives_in_ruleOpUnary2146); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1047:1: entryRuleXCastedExpression : ruleXCastedExpression EOF ; + public final void entryRuleXCastedExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1048:1: ( ruleXCastedExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1049:1: ruleXCastedExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionRule()); + } + pushFollow(FOLLOW_ruleXCastedExpression_in_entryRuleXCastedExpression2173); + ruleXCastedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXCastedExpression2180); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXCastedExpression" + + + // $ANTLR start "ruleXCastedExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1056:1: ruleXCastedExpression : ( ( rule__XCastedExpression__Group__0 ) ) ; + public final void ruleXCastedExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1060:2: ( ( ( rule__XCastedExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1061:1: ( ( rule__XCastedExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1061:1: ( ( rule__XCastedExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1062:1: ( rule__XCastedExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1063:1: ( rule__XCastedExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1063:2: rule__XCastedExpression__Group__0 + { + pushFollow(FOLLOW_rule__XCastedExpression__Group__0_in_ruleXCastedExpression2206); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1075:1: entryRuleXPostfixOperation : ruleXPostfixOperation EOF ; + public final void entryRuleXPostfixOperation() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1076:1: ( ruleXPostfixOperation EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1077:1: ruleXPostfixOperation EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationRule()); + } + pushFollow(FOLLOW_ruleXPostfixOperation_in_entryRuleXPostfixOperation2233); + ruleXPostfixOperation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXPostfixOperation2240); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXPostfixOperation" + + + // $ANTLR start "ruleXPostfixOperation" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1084:1: ruleXPostfixOperation : ( ( rule__XPostfixOperation__Group__0 ) ) ; + public final void ruleXPostfixOperation() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1088:2: ( ( ( rule__XPostfixOperation__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1089:1: ( ( rule__XPostfixOperation__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1089:1: ( ( rule__XPostfixOperation__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1090:1: ( rule__XPostfixOperation__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1091:1: ( rule__XPostfixOperation__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1091:2: rule__XPostfixOperation__Group__0 + { + pushFollow(FOLLOW_rule__XPostfixOperation__Group__0_in_ruleXPostfixOperation2266); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1103:1: entryRuleOpPostfix : ruleOpPostfix EOF ; + public final void entryRuleOpPostfix() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1104:1: ( ruleOpPostfix EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1105:1: ruleOpPostfix EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpPostfixRule()); + } + pushFollow(FOLLOW_ruleOpPostfix_in_entryRuleOpPostfix2293); + ruleOpPostfix(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpPostfixRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleOpPostfix2300); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpPostfix" + + + // $ANTLR start "ruleOpPostfix" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1112:1: ruleOpPostfix : ( ( rule__OpPostfix__Alternatives ) ) ; + public final void ruleOpPostfix() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1116:2: ( ( ( rule__OpPostfix__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1117:1: ( ( rule__OpPostfix__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1117:1: ( ( rule__OpPostfix__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1118:1: ( rule__OpPostfix__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpPostfixAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1119:1: ( rule__OpPostfix__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1119:2: rule__OpPostfix__Alternatives + { + pushFollow(FOLLOW_rule__OpPostfix__Alternatives_in_ruleOpPostfix2326); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1131:1: entryRuleXMemberFeatureCall : ruleXMemberFeatureCall EOF ; + public final void entryRuleXMemberFeatureCall() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1132:1: ( ruleXMemberFeatureCall EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1133:1: ruleXMemberFeatureCall EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallRule()); + } + pushFollow(FOLLOW_ruleXMemberFeatureCall_in_entryRuleXMemberFeatureCall2353); + ruleXMemberFeatureCall(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXMemberFeatureCall2360); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXMemberFeatureCall" + + + // $ANTLR start "ruleXMemberFeatureCall" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1140:1: ruleXMemberFeatureCall : ( ( rule__XMemberFeatureCall__Group__0 ) ) ; + public final void ruleXMemberFeatureCall() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1144:2: ( ( ( rule__XMemberFeatureCall__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1145:1: ( ( rule__XMemberFeatureCall__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1145:1: ( ( rule__XMemberFeatureCall__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1146:1: ( rule__XMemberFeatureCall__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1147:1: ( rule__XMemberFeatureCall__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1147:2: rule__XMemberFeatureCall__Group__0 + { + pushFollow(FOLLOW_rule__XMemberFeatureCall__Group__0_in_ruleXMemberFeatureCall2386); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1159:1: entryRuleXPrimaryExpression : ruleXPrimaryExpression EOF ; + public final void entryRuleXPrimaryExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1160:1: ( ruleXPrimaryExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1161:1: ruleXPrimaryExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionRule()); + } + pushFollow(FOLLOW_ruleXPrimaryExpression_in_entryRuleXPrimaryExpression2413); + ruleXPrimaryExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXPrimaryExpression2420); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXPrimaryExpression" + + + // $ANTLR start "ruleXPrimaryExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1168:1: ruleXPrimaryExpression : ( ( rule__XPrimaryExpression__Alternatives ) ) ; + public final void ruleXPrimaryExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1172:2: ( ( ( rule__XPrimaryExpression__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1173:1: ( ( rule__XPrimaryExpression__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1173:1: ( ( rule__XPrimaryExpression__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1174:1: ( rule__XPrimaryExpression__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1175:1: ( rule__XPrimaryExpression__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1175:2: rule__XPrimaryExpression__Alternatives + { + pushFollow(FOLLOW_rule__XPrimaryExpression__Alternatives_in_ruleXPrimaryExpression2446); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1187:1: entryRuleXLiteral : ruleXLiteral EOF ; + public final void entryRuleXLiteral() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1188:1: ( ruleXLiteral EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1189:1: ruleXLiteral EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralRule()); + } + pushFollow(FOLLOW_ruleXLiteral_in_entryRuleXLiteral2473); + ruleXLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXLiteral2480); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXLiteral" + + + // $ANTLR start "ruleXLiteral" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1196:1: ruleXLiteral : ( ( rule__XLiteral__Alternatives ) ) ; + public final void ruleXLiteral() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1200:2: ( ( ( rule__XLiteral__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1201:1: ( ( rule__XLiteral__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1201:1: ( ( rule__XLiteral__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1202:1: ( rule__XLiteral__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1203:1: ( rule__XLiteral__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1203:2: rule__XLiteral__Alternatives + { + pushFollow(FOLLOW_rule__XLiteral__Alternatives_in_ruleXLiteral2506); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1215:1: entryRuleXCollectionLiteral : ruleXCollectionLiteral EOF ; + public final void entryRuleXCollectionLiteral() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1216:1: ( ruleXCollectionLiteral EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1217:1: ruleXCollectionLiteral EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCollectionLiteralRule()); + } + pushFollow(FOLLOW_ruleXCollectionLiteral_in_entryRuleXCollectionLiteral2533); + ruleXCollectionLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCollectionLiteralRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXCollectionLiteral2540); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXCollectionLiteral" + + + // $ANTLR start "ruleXCollectionLiteral" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1224:1: ruleXCollectionLiteral : ( ( rule__XCollectionLiteral__Alternatives ) ) ; + public final void ruleXCollectionLiteral() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1228:2: ( ( ( rule__XCollectionLiteral__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1229:1: ( ( rule__XCollectionLiteral__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1229:1: ( ( rule__XCollectionLiteral__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1230:1: ( rule__XCollectionLiteral__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1231:1: ( rule__XCollectionLiteral__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1231:2: rule__XCollectionLiteral__Alternatives + { + pushFollow(FOLLOW_rule__XCollectionLiteral__Alternatives_in_ruleXCollectionLiteral2566); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1243:1: entryRuleXSetLiteral : ruleXSetLiteral EOF ; + public final void entryRuleXSetLiteral() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1244:1: ( ruleXSetLiteral EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1245:1: ruleXSetLiteral EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralRule()); + } + pushFollow(FOLLOW_ruleXSetLiteral_in_entryRuleXSetLiteral2593); + ruleXSetLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXSetLiteral2600); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXSetLiteral" + + + // $ANTLR start "ruleXSetLiteral" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1252:1: ruleXSetLiteral : ( ( rule__XSetLiteral__Group__0 ) ) ; + public final void ruleXSetLiteral() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1256:2: ( ( ( rule__XSetLiteral__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1257:1: ( ( rule__XSetLiteral__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1257:1: ( ( rule__XSetLiteral__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1258:1: ( rule__XSetLiteral__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1259:1: ( rule__XSetLiteral__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1259:2: rule__XSetLiteral__Group__0 + { + pushFollow(FOLLOW_rule__XSetLiteral__Group__0_in_ruleXSetLiteral2626); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1271:1: entryRuleXListLiteral : ruleXListLiteral EOF ; + public final void entryRuleXListLiteral() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1272:1: ( ruleXListLiteral EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1273:1: ruleXListLiteral EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralRule()); + } + pushFollow(FOLLOW_ruleXListLiteral_in_entryRuleXListLiteral2653); + ruleXListLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXListLiteral2660); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXListLiteral" + + + // $ANTLR start "ruleXListLiteral" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1280:1: ruleXListLiteral : ( ( rule__XListLiteral__Group__0 ) ) ; + public final void ruleXListLiteral() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1284:2: ( ( ( rule__XListLiteral__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1285:1: ( ( rule__XListLiteral__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1285:1: ( ( rule__XListLiteral__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1286:1: ( rule__XListLiteral__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1287:1: ( rule__XListLiteral__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1287:2: rule__XListLiteral__Group__0 + { + pushFollow(FOLLOW_rule__XListLiteral__Group__0_in_ruleXListLiteral2686); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1299:1: entryRuleXClosure : ruleXClosure EOF ; + public final void entryRuleXClosure() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1300:1: ( ruleXClosure EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1301:1: ruleXClosure EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureRule()); + } + pushFollow(FOLLOW_ruleXClosure_in_entryRuleXClosure2713); + ruleXClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXClosure2720); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXClosure" + + + // $ANTLR start "ruleXClosure" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1308:1: ruleXClosure : ( ( rule__XClosure__Group__0 ) ) ; + public final void ruleXClosure() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1312:2: ( ( ( rule__XClosure__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1313:1: ( ( rule__XClosure__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1313:1: ( ( rule__XClosure__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1314:1: ( rule__XClosure__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1315:1: ( rule__XClosure__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1315:2: rule__XClosure__Group__0 + { + pushFollow(FOLLOW_rule__XClosure__Group__0_in_ruleXClosure2746); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1327:1: entryRuleXExpressionInClosure : ruleXExpressionInClosure EOF ; + public final void entryRuleXExpressionInClosure() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1328:1: ( ruleXExpressionInClosure EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1329:1: ruleXExpressionInClosure EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureRule()); + } + pushFollow(FOLLOW_ruleXExpressionInClosure_in_entryRuleXExpressionInClosure2773); + ruleXExpressionInClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXExpressionInClosure2780); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXExpressionInClosure" + + + // $ANTLR start "ruleXExpressionInClosure" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1336:1: ruleXExpressionInClosure : ( ( rule__XExpressionInClosure__Group__0 ) ) ; + public final void ruleXExpressionInClosure() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1340:2: ( ( ( rule__XExpressionInClosure__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1341:1: ( ( rule__XExpressionInClosure__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1341:1: ( ( rule__XExpressionInClosure__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1342:1: ( rule__XExpressionInClosure__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1343:1: ( rule__XExpressionInClosure__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1343:2: rule__XExpressionInClosure__Group__0 + { + pushFollow(FOLLOW_rule__XExpressionInClosure__Group__0_in_ruleXExpressionInClosure2806); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1355:1: entryRuleXShortClosure : ruleXShortClosure EOF ; + public final void entryRuleXShortClosure() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1356:1: ( ruleXShortClosure EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1357:1: ruleXShortClosure EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureRule()); + } + pushFollow(FOLLOW_ruleXShortClosure_in_entryRuleXShortClosure2833); + ruleXShortClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXShortClosure2840); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXShortClosure" + + + // $ANTLR start "ruleXShortClosure" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1364:1: ruleXShortClosure : ( ( rule__XShortClosure__Group__0 ) ) ; + public final void ruleXShortClosure() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1368:2: ( ( ( rule__XShortClosure__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1369:1: ( ( rule__XShortClosure__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1369:1: ( ( rule__XShortClosure__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1370:1: ( rule__XShortClosure__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1371:1: ( rule__XShortClosure__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1371:2: rule__XShortClosure__Group__0 + { + pushFollow(FOLLOW_rule__XShortClosure__Group__0_in_ruleXShortClosure2866); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1383:1: entryRuleXParenthesizedExpression : ruleXParenthesizedExpression EOF ; + public final void entryRuleXParenthesizedExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1384:1: ( ruleXParenthesizedExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1385:1: ruleXParenthesizedExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXParenthesizedExpressionRule()); + } + pushFollow(FOLLOW_ruleXParenthesizedExpression_in_entryRuleXParenthesizedExpression2893); + ruleXParenthesizedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXParenthesizedExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXParenthesizedExpression2900); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXParenthesizedExpression" + + + // $ANTLR start "ruleXParenthesizedExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1392:1: ruleXParenthesizedExpression : ( ( rule__XParenthesizedExpression__Group__0 ) ) ; + public final void ruleXParenthesizedExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1396:2: ( ( ( rule__XParenthesizedExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1397:1: ( ( rule__XParenthesizedExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1397:1: ( ( rule__XParenthesizedExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1398:1: ( rule__XParenthesizedExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1399:1: ( rule__XParenthesizedExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1399:2: rule__XParenthesizedExpression__Group__0 + { + pushFollow(FOLLOW_rule__XParenthesizedExpression__Group__0_in_ruleXParenthesizedExpression2926); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1411:1: entryRuleXIfExpression : ruleXIfExpression EOF ; + public final void entryRuleXIfExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1412:1: ( ruleXIfExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1413:1: ruleXIfExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionRule()); + } + pushFollow(FOLLOW_ruleXIfExpression_in_entryRuleXIfExpression2953); + ruleXIfExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXIfExpression2960); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXIfExpression" + + + // $ANTLR start "ruleXIfExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1420:1: ruleXIfExpression : ( ( rule__XIfExpression__Group__0 ) ) ; + public final void ruleXIfExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1424:2: ( ( ( rule__XIfExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1425:1: ( ( rule__XIfExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1425:1: ( ( rule__XIfExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1426:1: ( rule__XIfExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1427:1: ( rule__XIfExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1427:2: rule__XIfExpression__Group__0 + { + pushFollow(FOLLOW_rule__XIfExpression__Group__0_in_ruleXIfExpression2986); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1439:1: entryRuleXSwitchExpression : ruleXSwitchExpression EOF ; + public final void entryRuleXSwitchExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1440:1: ( ruleXSwitchExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1441:1: ruleXSwitchExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionRule()); + } + pushFollow(FOLLOW_ruleXSwitchExpression_in_entryRuleXSwitchExpression3013); + ruleXSwitchExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXSwitchExpression3020); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXSwitchExpression" + + + // $ANTLR start "ruleXSwitchExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1448:1: ruleXSwitchExpression : ( ( rule__XSwitchExpression__Group__0 ) ) ; + public final void ruleXSwitchExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1452:2: ( ( ( rule__XSwitchExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1453:1: ( ( rule__XSwitchExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1453:1: ( ( rule__XSwitchExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1454:1: ( rule__XSwitchExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1455:1: ( rule__XSwitchExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1455:2: rule__XSwitchExpression__Group__0 + { + pushFollow(FOLLOW_rule__XSwitchExpression__Group__0_in_ruleXSwitchExpression3046); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1467:1: entryRuleXCasePart : ruleXCasePart EOF ; + public final void entryRuleXCasePart() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1468:1: ( ruleXCasePart EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1469:1: ruleXCasePart EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartRule()); + } + pushFollow(FOLLOW_ruleXCasePart_in_entryRuleXCasePart3073); + ruleXCasePart(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXCasePart3080); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXCasePart" + + + // $ANTLR start "ruleXCasePart" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1476:1: ruleXCasePart : ( ( rule__XCasePart__Group__0 ) ) ; + public final void ruleXCasePart() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1480:2: ( ( ( rule__XCasePart__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1481:1: ( ( rule__XCasePart__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1481:1: ( ( rule__XCasePart__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1482:1: ( rule__XCasePart__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1483:1: ( rule__XCasePart__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1483:2: rule__XCasePart__Group__0 + { + pushFollow(FOLLOW_rule__XCasePart__Group__0_in_ruleXCasePart3106); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1495:1: entryRuleXForLoopExpression : ruleXForLoopExpression EOF ; + public final void entryRuleXForLoopExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1496:1: ( ruleXForLoopExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1497:1: ruleXForLoopExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionRule()); + } + pushFollow(FOLLOW_ruleXForLoopExpression_in_entryRuleXForLoopExpression3133); + ruleXForLoopExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXForLoopExpression3140); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXForLoopExpression" + + + // $ANTLR start "ruleXForLoopExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1504:1: ruleXForLoopExpression : ( ( rule__XForLoopExpression__Group__0 ) ) ; + public final void ruleXForLoopExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1508:2: ( ( ( rule__XForLoopExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1509:1: ( ( rule__XForLoopExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1509:1: ( ( rule__XForLoopExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1510:1: ( rule__XForLoopExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1511:1: ( rule__XForLoopExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1511:2: rule__XForLoopExpression__Group__0 + { + pushFollow(FOLLOW_rule__XForLoopExpression__Group__0_in_ruleXForLoopExpression3166); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1523:1: entryRuleXBasicForLoopExpression : ruleXBasicForLoopExpression EOF ; + public final void entryRuleXBasicForLoopExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1524:1: ( ruleXBasicForLoopExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1525:1: ruleXBasicForLoopExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionRule()); + } + pushFollow(FOLLOW_ruleXBasicForLoopExpression_in_entryRuleXBasicForLoopExpression3193); + ruleXBasicForLoopExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXBasicForLoopExpression3200); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXBasicForLoopExpression" + + + // $ANTLR start "ruleXBasicForLoopExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1532:1: ruleXBasicForLoopExpression : ( ( rule__XBasicForLoopExpression__Group__0 ) ) ; + public final void ruleXBasicForLoopExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1536:2: ( ( ( rule__XBasicForLoopExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1537:1: ( ( rule__XBasicForLoopExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1537:1: ( ( rule__XBasicForLoopExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1538:1: ( rule__XBasicForLoopExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1539:1: ( rule__XBasicForLoopExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1539:2: rule__XBasicForLoopExpression__Group__0 + { + pushFollow(FOLLOW_rule__XBasicForLoopExpression__Group__0_in_ruleXBasicForLoopExpression3226); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1551:1: entryRuleXWhileExpression : ruleXWhileExpression EOF ; + public final void entryRuleXWhileExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1552:1: ( ruleXWhileExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1553:1: ruleXWhileExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionRule()); + } + pushFollow(FOLLOW_ruleXWhileExpression_in_entryRuleXWhileExpression3253); + ruleXWhileExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXWhileExpression3260); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXWhileExpression" + + + // $ANTLR start "ruleXWhileExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1560:1: ruleXWhileExpression : ( ( rule__XWhileExpression__Group__0 ) ) ; + public final void ruleXWhileExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1564:2: ( ( ( rule__XWhileExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1565:1: ( ( rule__XWhileExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1565:1: ( ( rule__XWhileExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1566:1: ( rule__XWhileExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1567:1: ( rule__XWhileExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1567:2: rule__XWhileExpression__Group__0 + { + pushFollow(FOLLOW_rule__XWhileExpression__Group__0_in_ruleXWhileExpression3286); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1579:1: entryRuleXDoWhileExpression : ruleXDoWhileExpression EOF ; + public final void entryRuleXDoWhileExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1580:1: ( ruleXDoWhileExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1581:1: ruleXDoWhileExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionRule()); + } + pushFollow(FOLLOW_ruleXDoWhileExpression_in_entryRuleXDoWhileExpression3313); + ruleXDoWhileExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXDoWhileExpression3320); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXDoWhileExpression" + + + // $ANTLR start "ruleXDoWhileExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1588:1: ruleXDoWhileExpression : ( ( rule__XDoWhileExpression__Group__0 ) ) ; + public final void ruleXDoWhileExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1592:2: ( ( ( rule__XDoWhileExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1593:1: ( ( rule__XDoWhileExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1593:1: ( ( rule__XDoWhileExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1594:1: ( rule__XDoWhileExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1595:1: ( rule__XDoWhileExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1595:2: rule__XDoWhileExpression__Group__0 + { + pushFollow(FOLLOW_rule__XDoWhileExpression__Group__0_in_ruleXDoWhileExpression3346); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1607:1: entryRuleXBlockExpression : ruleXBlockExpression EOF ; + public final void entryRuleXBlockExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1608:1: ( ruleXBlockExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1609:1: ruleXBlockExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionRule()); + } + pushFollow(FOLLOW_ruleXBlockExpression_in_entryRuleXBlockExpression3373); + ruleXBlockExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXBlockExpression3380); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXBlockExpression" + + + // $ANTLR start "ruleXBlockExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1616:1: ruleXBlockExpression : ( ( rule__XBlockExpression__Group__0 ) ) ; + public final void ruleXBlockExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1620:2: ( ( ( rule__XBlockExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1621:1: ( ( rule__XBlockExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1621:1: ( ( rule__XBlockExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1622:1: ( rule__XBlockExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1623:1: ( rule__XBlockExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1623:2: rule__XBlockExpression__Group__0 + { + pushFollow(FOLLOW_rule__XBlockExpression__Group__0_in_ruleXBlockExpression3406); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1635:1: entryRuleXExpressionOrVarDeclaration : ruleXExpressionOrVarDeclaration EOF ; + public final void entryRuleXExpressionOrVarDeclaration() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1636:1: ( ruleXExpressionOrVarDeclaration EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1637:1: ruleXExpressionOrVarDeclaration EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionOrVarDeclarationRule()); + } + pushFollow(FOLLOW_ruleXExpressionOrVarDeclaration_in_entryRuleXExpressionOrVarDeclaration3433); + ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionOrVarDeclarationRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXExpressionOrVarDeclaration3440); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXExpressionOrVarDeclaration" + + + // $ANTLR start "ruleXExpressionOrVarDeclaration" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1644:1: ruleXExpressionOrVarDeclaration : ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) ; + public final void ruleXExpressionOrVarDeclaration() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1648:2: ( ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1649:1: ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1649:1: ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1650:1: ( rule__XExpressionOrVarDeclaration__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1651:1: ( rule__XExpressionOrVarDeclaration__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1651:2: rule__XExpressionOrVarDeclaration__Alternatives + { + pushFollow(FOLLOW_rule__XExpressionOrVarDeclaration__Alternatives_in_ruleXExpressionOrVarDeclaration3466); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1663:1: entryRuleXVariableDeclaration : ruleXVariableDeclaration EOF ; + public final void entryRuleXVariableDeclaration() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1664:1: ( ruleXVariableDeclaration EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1665:1: ruleXVariableDeclaration EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationRule()); + } + pushFollow(FOLLOW_ruleXVariableDeclaration_in_entryRuleXVariableDeclaration3493); + ruleXVariableDeclaration(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXVariableDeclaration3500); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXVariableDeclaration" + + + // $ANTLR start "ruleXVariableDeclaration" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1672:1: ruleXVariableDeclaration : ( ( rule__XVariableDeclaration__Group__0 ) ) ; + public final void ruleXVariableDeclaration() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1676:2: ( ( ( rule__XVariableDeclaration__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1677:1: ( ( rule__XVariableDeclaration__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1677:1: ( ( rule__XVariableDeclaration__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1678:1: ( rule__XVariableDeclaration__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1679:1: ( rule__XVariableDeclaration__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1679:2: rule__XVariableDeclaration__Group__0 + { + pushFollow(FOLLOW_rule__XVariableDeclaration__Group__0_in_ruleXVariableDeclaration3526); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1691:1: entryRuleJvmFormalParameter : ruleJvmFormalParameter EOF ; + public final void entryRuleJvmFormalParameter() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1692:1: ( ruleJvmFormalParameter EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1693:1: ruleJvmFormalParameter EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmFormalParameterRule()); + } + pushFollow(FOLLOW_ruleJvmFormalParameter_in_entryRuleJvmFormalParameter3553); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmFormalParameterRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleJvmFormalParameter3560); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleJvmFormalParameter" + + + // $ANTLR start "ruleJvmFormalParameter" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1700:1: ruleJvmFormalParameter : ( ( rule__JvmFormalParameter__Group__0 ) ) ; + public final void ruleJvmFormalParameter() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1704:2: ( ( ( rule__JvmFormalParameter__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1705:1: ( ( rule__JvmFormalParameter__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1705:1: ( ( rule__JvmFormalParameter__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1706:1: ( rule__JvmFormalParameter__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmFormalParameterAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1707:1: ( rule__JvmFormalParameter__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1707:2: rule__JvmFormalParameter__Group__0 + { + pushFollow(FOLLOW_rule__JvmFormalParameter__Group__0_in_ruleJvmFormalParameter3586); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1719:1: entryRuleFullJvmFormalParameter : ruleFullJvmFormalParameter EOF ; + public final void entryRuleFullJvmFormalParameter() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1720:1: ( ruleFullJvmFormalParameter EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1721:1: ruleFullJvmFormalParameter EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFullJvmFormalParameterRule()); + } + pushFollow(FOLLOW_ruleFullJvmFormalParameter_in_entryRuleFullJvmFormalParameter3613); + ruleFullJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFullJvmFormalParameterRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleFullJvmFormalParameter3620); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleFullJvmFormalParameter" + + + // $ANTLR start "ruleFullJvmFormalParameter" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1728:1: ruleFullJvmFormalParameter : ( ( rule__FullJvmFormalParameter__Group__0 ) ) ; + public final void ruleFullJvmFormalParameter() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1732:2: ( ( ( rule__FullJvmFormalParameter__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1733:1: ( ( rule__FullJvmFormalParameter__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1733:1: ( ( rule__FullJvmFormalParameter__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1734:1: ( rule__FullJvmFormalParameter__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1735:1: ( rule__FullJvmFormalParameter__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1735:2: rule__FullJvmFormalParameter__Group__0 + { + pushFollow(FOLLOW_rule__FullJvmFormalParameter__Group__0_in_ruleFullJvmFormalParameter3646); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1747:1: entryRuleXFeatureCall : ruleXFeatureCall EOF ; + public final void entryRuleXFeatureCall() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1748:1: ( ruleXFeatureCall EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1749:1: ruleXFeatureCall EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallRule()); + } + pushFollow(FOLLOW_ruleXFeatureCall_in_entryRuleXFeatureCall3673); + ruleXFeatureCall(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXFeatureCall3680); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXFeatureCall" + + + // $ANTLR start "ruleXFeatureCall" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1756:1: ruleXFeatureCall : ( ( rule__XFeatureCall__Group__0 ) ) ; + public final void ruleXFeatureCall() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1760:2: ( ( ( rule__XFeatureCall__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1761:1: ( ( rule__XFeatureCall__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1761:1: ( ( rule__XFeatureCall__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1762:1: ( rule__XFeatureCall__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1763:1: ( rule__XFeatureCall__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1763:2: rule__XFeatureCall__Group__0 + { + pushFollow(FOLLOW_rule__XFeatureCall__Group__0_in_ruleXFeatureCall3706); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1775:1: entryRuleFeatureCallID : ruleFeatureCallID EOF ; + public final void entryRuleFeatureCallID() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1776:1: ( ruleFeatureCallID EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1777:1: ruleFeatureCallID EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDRule()); + } + pushFollow(FOLLOW_ruleFeatureCallID_in_entryRuleFeatureCallID3733); + ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleFeatureCallID3740); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleFeatureCallID" + + + // $ANTLR start "ruleFeatureCallID" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1784:1: ruleFeatureCallID : ( ( rule__FeatureCallID__Alternatives ) ) ; + public final void ruleFeatureCallID() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1788:2: ( ( ( rule__FeatureCallID__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1789:1: ( ( rule__FeatureCallID__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1789:1: ( ( rule__FeatureCallID__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1790:1: ( rule__FeatureCallID__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1791:1: ( rule__FeatureCallID__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1791:2: rule__FeatureCallID__Alternatives + { + pushFollow(FOLLOW_rule__FeatureCallID__Alternatives_in_ruleFeatureCallID3766); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1803:1: entryRuleIdOrSuper : ruleIdOrSuper EOF ; + public final void entryRuleIdOrSuper() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1804:1: ( ruleIdOrSuper EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1805:1: ruleIdOrSuper EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIdOrSuperRule()); + } + pushFollow(FOLLOW_ruleIdOrSuper_in_entryRuleIdOrSuper3793); + ruleIdOrSuper(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIdOrSuperRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleIdOrSuper3800); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleIdOrSuper" + + + // $ANTLR start "ruleIdOrSuper" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1812:1: ruleIdOrSuper : ( ( rule__IdOrSuper__Alternatives ) ) ; + public final void ruleIdOrSuper() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1816:2: ( ( ( rule__IdOrSuper__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1817:1: ( ( rule__IdOrSuper__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1817:1: ( ( rule__IdOrSuper__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1818:1: ( rule__IdOrSuper__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIdOrSuperAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1819:1: ( rule__IdOrSuper__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1819:2: rule__IdOrSuper__Alternatives + { + pushFollow(FOLLOW_rule__IdOrSuper__Alternatives_in_ruleIdOrSuper3826); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1831:1: entryRuleXConstructorCall : ruleXConstructorCall EOF ; + public final void entryRuleXConstructorCall() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1832:1: ( ruleXConstructorCall EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1833:1: ruleXConstructorCall EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallRule()); + } + pushFollow(FOLLOW_ruleXConstructorCall_in_entryRuleXConstructorCall3853); + ruleXConstructorCall(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXConstructorCall3860); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXConstructorCall" + + + // $ANTLR start "ruleXConstructorCall" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1840:1: ruleXConstructorCall : ( ( rule__XConstructorCall__Group__0 ) ) ; + public final void ruleXConstructorCall() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1844:2: ( ( ( rule__XConstructorCall__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1845:1: ( ( rule__XConstructorCall__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1845:1: ( ( rule__XConstructorCall__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1846:1: ( rule__XConstructorCall__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1847:1: ( rule__XConstructorCall__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1847:2: rule__XConstructorCall__Group__0 + { + pushFollow(FOLLOW_rule__XConstructorCall__Group__0_in_ruleXConstructorCall3886); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1859:1: entryRuleXBooleanLiteral : ruleXBooleanLiteral EOF ; + public final void entryRuleXBooleanLiteral() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1860:1: ( ruleXBooleanLiteral EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1861:1: ruleXBooleanLiteral EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralRule()); + } + pushFollow(FOLLOW_ruleXBooleanLiteral_in_entryRuleXBooleanLiteral3913); + ruleXBooleanLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXBooleanLiteral3920); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXBooleanLiteral" + + + // $ANTLR start "ruleXBooleanLiteral" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1868:1: ruleXBooleanLiteral : ( ( rule__XBooleanLiteral__Group__0 ) ) ; + public final void ruleXBooleanLiteral() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1872:2: ( ( ( rule__XBooleanLiteral__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1873:1: ( ( rule__XBooleanLiteral__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1873:1: ( ( rule__XBooleanLiteral__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1874:1: ( rule__XBooleanLiteral__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1875:1: ( rule__XBooleanLiteral__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1875:2: rule__XBooleanLiteral__Group__0 + { + pushFollow(FOLLOW_rule__XBooleanLiteral__Group__0_in_ruleXBooleanLiteral3946); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1887:1: entryRuleXNullLiteral : ruleXNullLiteral EOF ; + public final void entryRuleXNullLiteral() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1888:1: ( ruleXNullLiteral EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1889:1: ruleXNullLiteral EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNullLiteralRule()); + } + pushFollow(FOLLOW_ruleXNullLiteral_in_entryRuleXNullLiteral3973); + ruleXNullLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXNullLiteralRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXNullLiteral3980); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXNullLiteral" + + + // $ANTLR start "ruleXNullLiteral" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1896:1: ruleXNullLiteral : ( ( rule__XNullLiteral__Group__0 ) ) ; + public final void ruleXNullLiteral() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1900:2: ( ( ( rule__XNullLiteral__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1901:1: ( ( rule__XNullLiteral__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1901:1: ( ( rule__XNullLiteral__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1902:1: ( rule__XNullLiteral__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNullLiteralAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1903:1: ( rule__XNullLiteral__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1903:2: rule__XNullLiteral__Group__0 + { + pushFollow(FOLLOW_rule__XNullLiteral__Group__0_in_ruleXNullLiteral4006); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1915:1: entryRuleXNumberLiteral : ruleXNumberLiteral EOF ; + public final void entryRuleXNumberLiteral() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1916:1: ( ruleXNumberLiteral EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1917:1: ruleXNumberLiteral EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNumberLiteralRule()); + } + pushFollow(FOLLOW_ruleXNumberLiteral_in_entryRuleXNumberLiteral4033); + ruleXNumberLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXNumberLiteralRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXNumberLiteral4040); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXNumberLiteral" + + + // $ANTLR start "ruleXNumberLiteral" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1924:1: ruleXNumberLiteral : ( ( rule__XNumberLiteral__Group__0 ) ) ; + public final void ruleXNumberLiteral() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1928:2: ( ( ( rule__XNumberLiteral__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1929:1: ( ( rule__XNumberLiteral__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1929:1: ( ( rule__XNumberLiteral__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1930:1: ( rule__XNumberLiteral__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNumberLiteralAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1931:1: ( rule__XNumberLiteral__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1931:2: rule__XNumberLiteral__Group__0 + { + pushFollow(FOLLOW_rule__XNumberLiteral__Group__0_in_ruleXNumberLiteral4066); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1943:1: entryRuleXStringLiteral : ruleXStringLiteral EOF ; + public final void entryRuleXStringLiteral() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1944:1: ( ruleXStringLiteral EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1945:1: ruleXStringLiteral EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXStringLiteralRule()); + } + pushFollow(FOLLOW_ruleXStringLiteral_in_entryRuleXStringLiteral4093); + ruleXStringLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXStringLiteralRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXStringLiteral4100); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXStringLiteral" + + + // $ANTLR start "ruleXStringLiteral" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1952:1: ruleXStringLiteral : ( ( rule__XStringLiteral__Group__0 ) ) ; + public final void ruleXStringLiteral() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1956:2: ( ( ( rule__XStringLiteral__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1957:1: ( ( rule__XStringLiteral__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1957:1: ( ( rule__XStringLiteral__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1958:1: ( rule__XStringLiteral__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXStringLiteralAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1959:1: ( rule__XStringLiteral__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1959:2: rule__XStringLiteral__Group__0 + { + pushFollow(FOLLOW_rule__XStringLiteral__Group__0_in_ruleXStringLiteral4126); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1971:1: entryRuleXTypeLiteral : ruleXTypeLiteral EOF ; + public final void entryRuleXTypeLiteral() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1972:1: ( ruleXTypeLiteral EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1973:1: ruleXTypeLiteral EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralRule()); + } + pushFollow(FOLLOW_ruleXTypeLiteral_in_entryRuleXTypeLiteral4153); + ruleXTypeLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXTypeLiteral4160); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXTypeLiteral" + + + // $ANTLR start "ruleXTypeLiteral" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1980:1: ruleXTypeLiteral : ( ( rule__XTypeLiteral__Group__0 ) ) ; + public final void ruleXTypeLiteral() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1984:2: ( ( ( rule__XTypeLiteral__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1985:1: ( ( rule__XTypeLiteral__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1985:1: ( ( rule__XTypeLiteral__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1986:1: ( rule__XTypeLiteral__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1987:1: ( rule__XTypeLiteral__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1987:2: rule__XTypeLiteral__Group__0 + { + pushFollow(FOLLOW_rule__XTypeLiteral__Group__0_in_ruleXTypeLiteral4186); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:1999:1: entryRuleXThrowExpression : ruleXThrowExpression EOF ; + public final void entryRuleXThrowExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2000:1: ( ruleXThrowExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2001:1: ruleXThrowExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXThrowExpressionRule()); + } + pushFollow(FOLLOW_ruleXThrowExpression_in_entryRuleXThrowExpression4213); + ruleXThrowExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXThrowExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXThrowExpression4220); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXThrowExpression" + + + // $ANTLR start "ruleXThrowExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2008:1: ruleXThrowExpression : ( ( rule__XThrowExpression__Group__0 ) ) ; + public final void ruleXThrowExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2012:2: ( ( ( rule__XThrowExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2013:1: ( ( rule__XThrowExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2013:1: ( ( rule__XThrowExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2014:1: ( rule__XThrowExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXThrowExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2015:1: ( rule__XThrowExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2015:2: rule__XThrowExpression__Group__0 + { + pushFollow(FOLLOW_rule__XThrowExpression__Group__0_in_ruleXThrowExpression4246); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2027:1: entryRuleXReturnExpression : ruleXReturnExpression EOF ; + public final void entryRuleXReturnExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2028:1: ( ruleXReturnExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2029:1: ruleXReturnExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXReturnExpressionRule()); + } + pushFollow(FOLLOW_ruleXReturnExpression_in_entryRuleXReturnExpression4273); + ruleXReturnExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXReturnExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXReturnExpression4280); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXReturnExpression" + + + // $ANTLR start "ruleXReturnExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2036:1: ruleXReturnExpression : ( ( rule__XReturnExpression__Group__0 ) ) ; + public final void ruleXReturnExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2040:2: ( ( ( rule__XReturnExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2041:1: ( ( rule__XReturnExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2041:1: ( ( rule__XReturnExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2042:1: ( rule__XReturnExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXReturnExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2043:1: ( rule__XReturnExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2043:2: rule__XReturnExpression__Group__0 + { + pushFollow(FOLLOW_rule__XReturnExpression__Group__0_in_ruleXReturnExpression4306); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2055:1: entryRuleXTryCatchFinallyExpression : ruleXTryCatchFinallyExpression EOF ; + public final void entryRuleXTryCatchFinallyExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2056:1: ( ruleXTryCatchFinallyExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2057:1: ruleXTryCatchFinallyExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + pushFollow(FOLLOW_ruleXTryCatchFinallyExpression_in_entryRuleXTryCatchFinallyExpression4333); + ruleXTryCatchFinallyExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXTryCatchFinallyExpression4340); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXTryCatchFinallyExpression" + + + // $ANTLR start "ruleXTryCatchFinallyExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2064:1: ruleXTryCatchFinallyExpression : ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) ; + public final void ruleXTryCatchFinallyExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2068:2: ( ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2069:1: ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2069:1: ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2070:1: ( rule__XTryCatchFinallyExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2071:1: ( rule__XTryCatchFinallyExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2071:2: rule__XTryCatchFinallyExpression__Group__0 + { + pushFollow(FOLLOW_rule__XTryCatchFinallyExpression__Group__0_in_ruleXTryCatchFinallyExpression4366); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2083:1: entryRuleXSynchronizedExpression : ruleXSynchronizedExpression EOF ; + public final void entryRuleXSynchronizedExpression() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2084:1: ( ruleXSynchronizedExpression EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2085:1: ruleXSynchronizedExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionRule()); + } + pushFollow(FOLLOW_ruleXSynchronizedExpression_in_entryRuleXSynchronizedExpression4393); + ruleXSynchronizedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXSynchronizedExpression4400); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXSynchronizedExpression" + + + // $ANTLR start "ruleXSynchronizedExpression" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2092:1: ruleXSynchronizedExpression : ( ( rule__XSynchronizedExpression__Group__0 ) ) ; + public final void ruleXSynchronizedExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2096:2: ( ( ( rule__XSynchronizedExpression__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2097:1: ( ( rule__XSynchronizedExpression__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2097:1: ( ( rule__XSynchronizedExpression__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2098:1: ( rule__XSynchronizedExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2099:1: ( rule__XSynchronizedExpression__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2099:2: rule__XSynchronizedExpression__Group__0 + { + pushFollow(FOLLOW_rule__XSynchronizedExpression__Group__0_in_ruleXSynchronizedExpression4426); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2111:1: entryRuleXCatchClause : ruleXCatchClause EOF ; + public final void entryRuleXCatchClause() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2112:1: ( ruleXCatchClause EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2113:1: ruleXCatchClause EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseRule()); + } + pushFollow(FOLLOW_ruleXCatchClause_in_entryRuleXCatchClause4453); + ruleXCatchClause(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXCatchClause4460); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXCatchClause" + + + // $ANTLR start "ruleXCatchClause" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2120:1: ruleXCatchClause : ( ( rule__XCatchClause__Group__0 ) ) ; + public final void ruleXCatchClause() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2124:2: ( ( ( rule__XCatchClause__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2125:1: ( ( rule__XCatchClause__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2125:1: ( ( rule__XCatchClause__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2126:1: ( rule__XCatchClause__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2127:1: ( rule__XCatchClause__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2127:2: rule__XCatchClause__Group__0 + { + pushFollow(FOLLOW_rule__XCatchClause__Group__0_in_ruleXCatchClause4486); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2139:1: entryRuleQualifiedName : ruleQualifiedName EOF ; + public final void entryRuleQualifiedName() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2140:1: ( ruleQualifiedName EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2141:1: ruleQualifiedName EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameRule()); + } + pushFollow(FOLLOW_ruleQualifiedName_in_entryRuleQualifiedName4513); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleQualifiedName4520); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleQualifiedName" + + + // $ANTLR start "ruleQualifiedName" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2148:1: ruleQualifiedName : ( ( rule__QualifiedName__Group__0 ) ) ; + public final void ruleQualifiedName() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2152:2: ( ( ( rule__QualifiedName__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2153:1: ( ( rule__QualifiedName__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2153:1: ( ( rule__QualifiedName__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2154:1: ( rule__QualifiedName__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2155:1: ( rule__QualifiedName__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2155:2: rule__QualifiedName__Group__0 + { + pushFollow(FOLLOW_rule__QualifiedName__Group__0_in_ruleQualifiedName4546); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2167:1: entryRuleNumber : ruleNumber EOF ; + public final void entryRuleNumber() throws RecognitionException { + + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2171:1: ( ruleNumber EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2172:1: ruleNumber EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberRule()); + } + pushFollow(FOLLOW_ruleNumber_in_entryRuleNumber4578); + ruleNumber(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleNumber4585); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + myHiddenTokenState.restore(); + + } + return ; + } + // $ANTLR end "entryRuleNumber" + + + // $ANTLR start "ruleNumber" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2182:1: ruleNumber : ( ( rule__Number__Alternatives ) ) ; + public final void ruleNumber() throws RecognitionException { + + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2187:2: ( ( ( rule__Number__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2188:1: ( ( rule__Number__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2188:1: ( ( rule__Number__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2189:1: ( rule__Number__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2190:1: ( rule__Number__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2190:2: rule__Number__Alternatives + { + pushFollow(FOLLOW_rule__Number__Alternatives_in_ruleNumber4615); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2205:1: entryRuleJvmTypeReference : ruleJvmTypeReference EOF ; + public final void entryRuleJvmTypeReference() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2206:1: ( ruleJvmTypeReference EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2207:1: ruleJvmTypeReference EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceRule()); + } + pushFollow(FOLLOW_ruleJvmTypeReference_in_entryRuleJvmTypeReference4644); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleJvmTypeReference4651); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleJvmTypeReference" + + + // $ANTLR start "ruleJvmTypeReference" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2214:1: ruleJvmTypeReference : ( ( rule__JvmTypeReference__Alternatives ) ) ; + public final void ruleJvmTypeReference() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2218:2: ( ( ( rule__JvmTypeReference__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2219:1: ( ( rule__JvmTypeReference__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2219:1: ( ( rule__JvmTypeReference__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2220:1: ( rule__JvmTypeReference__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2221:1: ( rule__JvmTypeReference__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2221:2: rule__JvmTypeReference__Alternatives + { + pushFollow(FOLLOW_rule__JvmTypeReference__Alternatives_in_ruleJvmTypeReference4677); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2233:1: entryRuleArrayBrackets : ruleArrayBrackets EOF ; + public final void entryRuleArrayBrackets() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2234:1: ( ruleArrayBrackets EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2235:1: ruleArrayBrackets EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getArrayBracketsRule()); + } + pushFollow(FOLLOW_ruleArrayBrackets_in_entryRuleArrayBrackets4704); + ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getArrayBracketsRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleArrayBrackets4711); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleArrayBrackets" + + + // $ANTLR start "ruleArrayBrackets" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2242:1: ruleArrayBrackets : ( ( rule__ArrayBrackets__Group__0 ) ) ; + public final void ruleArrayBrackets() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2246:2: ( ( ( rule__ArrayBrackets__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2247:1: ( ( rule__ArrayBrackets__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2247:1: ( ( rule__ArrayBrackets__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2248:1: ( rule__ArrayBrackets__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getArrayBracketsAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2249:1: ( rule__ArrayBrackets__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2249:2: rule__ArrayBrackets__Group__0 + { + pushFollow(FOLLOW_rule__ArrayBrackets__Group__0_in_ruleArrayBrackets4737); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2261:1: entryRuleXFunctionTypeRef : ruleXFunctionTypeRef EOF ; + public final void entryRuleXFunctionTypeRef() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2262:1: ( ruleXFunctionTypeRef EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2263:1: ruleXFunctionTypeRef EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefRule()); + } + pushFollow(FOLLOW_ruleXFunctionTypeRef_in_entryRuleXFunctionTypeRef4764); + ruleXFunctionTypeRef(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXFunctionTypeRef4771); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXFunctionTypeRef" + + + // $ANTLR start "ruleXFunctionTypeRef" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2270:1: ruleXFunctionTypeRef : ( ( rule__XFunctionTypeRef__Group__0 ) ) ; + public final void ruleXFunctionTypeRef() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2274:2: ( ( ( rule__XFunctionTypeRef__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2275:1: ( ( rule__XFunctionTypeRef__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2275:1: ( ( rule__XFunctionTypeRef__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2276:1: ( rule__XFunctionTypeRef__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2277:1: ( rule__XFunctionTypeRef__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2277:2: rule__XFunctionTypeRef__Group__0 + { + pushFollow(FOLLOW_rule__XFunctionTypeRef__Group__0_in_ruleXFunctionTypeRef4797); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2289:1: entryRuleJvmParameterizedTypeReference : ruleJvmParameterizedTypeReference EOF ; + public final void entryRuleJvmParameterizedTypeReference() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2290:1: ( ruleJvmParameterizedTypeReference EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2291:1: ruleJvmParameterizedTypeReference EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + pushFollow(FOLLOW_ruleJvmParameterizedTypeReference_in_entryRuleJvmParameterizedTypeReference4824); + ruleJvmParameterizedTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleJvmParameterizedTypeReference4831); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleJvmParameterizedTypeReference" + + + // $ANTLR start "ruleJvmParameterizedTypeReference" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2298:1: ruleJvmParameterizedTypeReference : ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) ; + public final void ruleJvmParameterizedTypeReference() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2302:2: ( ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2303:1: ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2303:1: ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2304:1: ( rule__JvmParameterizedTypeReference__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2305:1: ( rule__JvmParameterizedTypeReference__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2305:2: rule__JvmParameterizedTypeReference__Group__0 + { + pushFollow(FOLLOW_rule__JvmParameterizedTypeReference__Group__0_in_ruleJvmParameterizedTypeReference4857); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2317:1: entryRuleJvmArgumentTypeReference : ruleJvmArgumentTypeReference EOF ; + public final void entryRuleJvmArgumentTypeReference() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2318:1: ( ruleJvmArgumentTypeReference EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2319:1: ruleJvmArgumentTypeReference EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmArgumentTypeReferenceRule()); + } + pushFollow(FOLLOW_ruleJvmArgumentTypeReference_in_entryRuleJvmArgumentTypeReference4884); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmArgumentTypeReferenceRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleJvmArgumentTypeReference4891); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleJvmArgumentTypeReference" + + + // $ANTLR start "ruleJvmArgumentTypeReference" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2326:1: ruleJvmArgumentTypeReference : ( ( rule__JvmArgumentTypeReference__Alternatives ) ) ; + public final void ruleJvmArgumentTypeReference() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2330:2: ( ( ( rule__JvmArgumentTypeReference__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2331:1: ( ( rule__JvmArgumentTypeReference__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2331:1: ( ( rule__JvmArgumentTypeReference__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2332:1: ( rule__JvmArgumentTypeReference__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2333:1: ( rule__JvmArgumentTypeReference__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2333:2: rule__JvmArgumentTypeReference__Alternatives + { + pushFollow(FOLLOW_rule__JvmArgumentTypeReference__Alternatives_in_ruleJvmArgumentTypeReference4917); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2345:1: entryRuleJvmWildcardTypeReference : ruleJvmWildcardTypeReference EOF ; + public final void entryRuleJvmWildcardTypeReference() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2346:1: ( ruleJvmWildcardTypeReference EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2347:1: ruleJvmWildcardTypeReference EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + pushFollow(FOLLOW_ruleJvmWildcardTypeReference_in_entryRuleJvmWildcardTypeReference4944); + ruleJvmWildcardTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleJvmWildcardTypeReference4951); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleJvmWildcardTypeReference" + + + // $ANTLR start "ruleJvmWildcardTypeReference" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2354:1: ruleJvmWildcardTypeReference : ( ( rule__JvmWildcardTypeReference__Group__0 ) ) ; + public final void ruleJvmWildcardTypeReference() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2358:2: ( ( ( rule__JvmWildcardTypeReference__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2359:1: ( ( rule__JvmWildcardTypeReference__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2359:1: ( ( rule__JvmWildcardTypeReference__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2360:1: ( rule__JvmWildcardTypeReference__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2361:1: ( rule__JvmWildcardTypeReference__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2361:2: rule__JvmWildcardTypeReference__Group__0 + { + pushFollow(FOLLOW_rule__JvmWildcardTypeReference__Group__0_in_ruleJvmWildcardTypeReference4977); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2373:1: entryRuleJvmUpperBound : ruleJvmUpperBound EOF ; + public final void entryRuleJvmUpperBound() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2374:1: ( ruleJvmUpperBound EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2375:1: ruleJvmUpperBound EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundRule()); + } + pushFollow(FOLLOW_ruleJvmUpperBound_in_entryRuleJvmUpperBound5004); + ruleJvmUpperBound(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleJvmUpperBound5011); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleJvmUpperBound" + + + // $ANTLR start "ruleJvmUpperBound" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2382:1: ruleJvmUpperBound : ( ( rule__JvmUpperBound__Group__0 ) ) ; + public final void ruleJvmUpperBound() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2386:2: ( ( ( rule__JvmUpperBound__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2387:1: ( ( rule__JvmUpperBound__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2387:1: ( ( rule__JvmUpperBound__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2388:1: ( rule__JvmUpperBound__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2389:1: ( rule__JvmUpperBound__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2389:2: rule__JvmUpperBound__Group__0 + { + pushFollow(FOLLOW_rule__JvmUpperBound__Group__0_in_ruleJvmUpperBound5037); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2401:1: entryRuleJvmUpperBoundAnded : ruleJvmUpperBoundAnded EOF ; + public final void entryRuleJvmUpperBoundAnded() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2402:1: ( ruleJvmUpperBoundAnded EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2403:1: ruleJvmUpperBoundAnded EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAndedRule()); + } + pushFollow(FOLLOW_ruleJvmUpperBoundAnded_in_entryRuleJvmUpperBoundAnded5064); + ruleJvmUpperBoundAnded(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAndedRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleJvmUpperBoundAnded5071); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleJvmUpperBoundAnded" + + + // $ANTLR start "ruleJvmUpperBoundAnded" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2410:1: ruleJvmUpperBoundAnded : ( ( rule__JvmUpperBoundAnded__Group__0 ) ) ; + public final void ruleJvmUpperBoundAnded() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2414:2: ( ( ( rule__JvmUpperBoundAnded__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2415:1: ( ( rule__JvmUpperBoundAnded__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2415:1: ( ( rule__JvmUpperBoundAnded__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2416:1: ( rule__JvmUpperBoundAnded__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2417:1: ( rule__JvmUpperBoundAnded__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2417:2: rule__JvmUpperBoundAnded__Group__0 + { + pushFollow(FOLLOW_rule__JvmUpperBoundAnded__Group__0_in_ruleJvmUpperBoundAnded5097); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2429:1: entryRuleJvmLowerBound : ruleJvmLowerBound EOF ; + public final void entryRuleJvmLowerBound() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2430:1: ( ruleJvmLowerBound EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2431:1: ruleJvmLowerBound EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundRule()); + } + pushFollow(FOLLOW_ruleJvmLowerBound_in_entryRuleJvmLowerBound5124); + ruleJvmLowerBound(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleJvmLowerBound5131); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleJvmLowerBound" + + + // $ANTLR start "ruleJvmLowerBound" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2438:1: ruleJvmLowerBound : ( ( rule__JvmLowerBound__Group__0 ) ) ; + public final void ruleJvmLowerBound() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2442:2: ( ( ( rule__JvmLowerBound__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2443:1: ( ( rule__JvmLowerBound__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2443:1: ( ( rule__JvmLowerBound__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2444:1: ( rule__JvmLowerBound__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2445:1: ( rule__JvmLowerBound__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2445:2: rule__JvmLowerBound__Group__0 + { + pushFollow(FOLLOW_rule__JvmLowerBound__Group__0_in_ruleJvmLowerBound5157); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2457:1: entryRuleJvmLowerBoundAnded : ruleJvmLowerBoundAnded EOF ; + public final void entryRuleJvmLowerBoundAnded() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2458:1: ( ruleJvmLowerBoundAnded EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2459:1: ruleJvmLowerBoundAnded EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAndedRule()); + } + pushFollow(FOLLOW_ruleJvmLowerBoundAnded_in_entryRuleJvmLowerBoundAnded5184); + ruleJvmLowerBoundAnded(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAndedRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleJvmLowerBoundAnded5191); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleJvmLowerBoundAnded" + + + // $ANTLR start "ruleJvmLowerBoundAnded" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2466:1: ruleJvmLowerBoundAnded : ( ( rule__JvmLowerBoundAnded__Group__0 ) ) ; + public final void ruleJvmLowerBoundAnded() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2470:2: ( ( ( rule__JvmLowerBoundAnded__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2471:1: ( ( rule__JvmLowerBoundAnded__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2471:1: ( ( rule__JvmLowerBoundAnded__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2472:1: ( rule__JvmLowerBoundAnded__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2473:1: ( rule__JvmLowerBoundAnded__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2473:2: rule__JvmLowerBoundAnded__Group__0 + { + pushFollow(FOLLOW_rule__JvmLowerBoundAnded__Group__0_in_ruleJvmLowerBoundAnded5217); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2487:1: entryRuleQualifiedNameWithWildcard : ruleQualifiedNameWithWildcard EOF ; + public final void entryRuleQualifiedNameWithWildcard() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2488:1: ( ruleQualifiedNameWithWildcard EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2489:1: ruleQualifiedNameWithWildcard EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameWithWildcardRule()); + } + pushFollow(FOLLOW_ruleQualifiedNameWithWildcard_in_entryRuleQualifiedNameWithWildcard5246); + ruleQualifiedNameWithWildcard(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameWithWildcardRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleQualifiedNameWithWildcard5253); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleQualifiedNameWithWildcard" + + + // $ANTLR start "ruleQualifiedNameWithWildcard" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2496:1: ruleQualifiedNameWithWildcard : ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) ; + public final void ruleQualifiedNameWithWildcard() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2500:2: ( ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2501:1: ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2501:1: ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2502:1: ( rule__QualifiedNameWithWildcard__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2503:1: ( rule__QualifiedNameWithWildcard__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2503:2: rule__QualifiedNameWithWildcard__Group__0 + { + pushFollow(FOLLOW_rule__QualifiedNameWithWildcard__Group__0_in_ruleQualifiedNameWithWildcard5279); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2515:1: entryRuleValidID : ruleValidID EOF ; + public final void entryRuleValidID() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2516:1: ( ruleValidID EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2517:1: ruleValidID EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getValidIDRule()); + } + pushFollow(FOLLOW_ruleValidID_in_entryRuleValidID5306); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getValidIDRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleValidID5313); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleValidID" + + + // $ANTLR start "ruleValidID" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2524:1: ruleValidID : ( RULE_ID ) ; + public final void ruleValidID() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2528:2: ( ( RULE_ID ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2529:1: ( RULE_ID ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2529:1: ( RULE_ID ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2530:1: RULE_ID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); + } + match(input,RULE_ID,FOLLOW_RULE_ID_in_ruleValidID5339); 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 "entryRuleXImportDeclaration" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2545:1: entryRuleXImportDeclaration : ruleXImportDeclaration EOF ; + public final void entryRuleXImportDeclaration() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2546:1: ( ruleXImportDeclaration EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2547:1: ruleXImportDeclaration EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationRule()); + } + pushFollow(FOLLOW_ruleXImportDeclaration_in_entryRuleXImportDeclaration5367); + ruleXImportDeclaration(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleXImportDeclaration5374); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXImportDeclaration" + + + // $ANTLR start "ruleXImportDeclaration" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2554:1: ruleXImportDeclaration : ( ( rule__XImportDeclaration__Group__0 ) ) ; + public final void ruleXImportDeclaration() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2558:2: ( ( ( rule__XImportDeclaration__Group__0 ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2559:1: ( ( rule__XImportDeclaration__Group__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2559:1: ( ( rule__XImportDeclaration__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2560:1: ( rule__XImportDeclaration__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2561:1: ( rule__XImportDeclaration__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2561:2: rule__XImportDeclaration__Group__0 + { + pushFollow(FOLLOW_rule__XImportDeclaration__Group__0_in_ruleXImportDeclaration5400); + 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 "entryRuleQualifiedNameInStaticImport" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2573:1: entryRuleQualifiedNameInStaticImport : ruleQualifiedNameInStaticImport EOF ; + public final void entryRuleQualifiedNameInStaticImport() throws RecognitionException { + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2574:1: ( ruleQualifiedNameInStaticImport EOF ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2575:1: ruleQualifiedNameInStaticImport EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameInStaticImportRule()); + } + pushFollow(FOLLOW_ruleQualifiedNameInStaticImport_in_entryRuleQualifiedNameInStaticImport5427); + ruleQualifiedNameInStaticImport(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameInStaticImportRule()); + } + match(input,EOF,FOLLOW_EOF_in_entryRuleQualifiedNameInStaticImport5434); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleQualifiedNameInStaticImport" + + + // $ANTLR start "ruleQualifiedNameInStaticImport" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2582:1: ruleQualifiedNameInStaticImport : ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) ; + public final void ruleQualifiedNameInStaticImport() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2586:2: ( ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2587:1: ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2587:1: ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2588:1: ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2588:1: ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2589:1: ( rule__QualifiedNameInStaticImport__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2590:1: ( rule__QualifiedNameInStaticImport__Group__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2590:2: rule__QualifiedNameInStaticImport__Group__0 + { + pushFollow(FOLLOW_rule__QualifiedNameInStaticImport__Group__0_in_ruleQualifiedNameInStaticImport5462); + rule__QualifiedNameInStaticImport__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); + } + + } + + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2593:1: ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2594:1: ( rule__QualifiedNameInStaticImport__Group__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2595:1: ( rule__QualifiedNameInStaticImport__Group__0 )* + loop2: + do { + int alt2=2; + int LA2_0 = input.LA(1); + + if ( (LA2_0==RULE_ID) ) { + int LA2_2 = input.LA(2); + + if ( (LA2_2==43) ) { + alt2=1; + } + + + } + + + switch (alt2) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2595:2: rule__QualifiedNameInStaticImport__Group__0 + { + pushFollow(FOLLOW_rule__QualifiedNameInStaticImport__Group__0_in_ruleQualifiedNameInStaticImport5474); + rule__QualifiedNameInStaticImport__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop2; + } + } 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 "ruleLayoutingEnum" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2609:1: ruleLayoutingEnum : ( ( rule__LayoutingEnum__Alternatives ) ) ; + public final void ruleLayoutingEnum() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2613:1: ( ( ( rule__LayoutingEnum__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2614:1: ( ( rule__LayoutingEnum__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2614:1: ( ( rule__LayoutingEnum__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2615:1: ( rule__LayoutingEnum__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLayoutingEnumAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2616:1: ( rule__LayoutingEnum__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2616:2: rule__LayoutingEnum__Alternatives + { + pushFollow(FOLLOW_rule__LayoutingEnum__Alternatives_in_ruleLayoutingEnum5514); + rule__LayoutingEnum__Alternatives(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getLayoutingEnumAccess().getAlternatives()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleLayoutingEnum" + + + // $ANTLR start "ruleFocusingEnum" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2628:1: ruleFocusingEnum : ( ( rule__FocusingEnum__Alternatives ) ) ; + public final void ruleFocusingEnum() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2632:1: ( ( ( rule__FocusingEnum__Alternatives ) ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2633:1: ( ( rule__FocusingEnum__Alternatives ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2633:1: ( ( rule__FocusingEnum__Alternatives ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2634:1: ( rule__FocusingEnum__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFocusingEnumAccess().getAlternatives()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2635:1: ( rule__FocusingEnum__Alternatives ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2635:2: rule__FocusingEnum__Alternatives + { + pushFollow(FOLLOW_rule__FocusingEnum__Alternatives_in_ruleFocusingEnum5550); + rule__FocusingEnum__Alternatives(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getFocusingEnumAccess().getAlternatives()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleFocusingEnum" + + + // $ANTLR start "rule__XAnnotation__Alternatives_3_1" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2646: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 { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2650:1: ( ( ( rule__XAnnotation__Group_3_1_0__0 ) ) | ( ( rule__XAnnotation__ValueAssignment_3_1_1 ) ) ) + int alt3=2; + alt3 = dfa3.predict(input); + switch (alt3) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2651:1: ( ( rule__XAnnotation__Group_3_1_0__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2651:1: ( ( rule__XAnnotation__Group_3_1_0__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2652:1: ( rule__XAnnotation__Group_3_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationAccess().getGroup_3_1_0()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2653:1: ( rule__XAnnotation__Group_3_1_0__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2653:2: rule__XAnnotation__Group_3_1_0__0 + { + pushFollow(FOLLOW_rule__XAnnotation__Group_3_1_0__0_in_rule__XAnnotation__Alternatives_3_15585); + 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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2657:6: ( ( rule__XAnnotation__ValueAssignment_3_1_1 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2657:6: ( ( rule__XAnnotation__ValueAssignment_3_1_1 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2658:1: ( rule__XAnnotation__ValueAssignment_3_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationAccess().getValueAssignment_3_1_1()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2659:1: ( rule__XAnnotation__ValueAssignment_3_1_1 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2659:2: rule__XAnnotation__ValueAssignment_3_1_1 + { + pushFollow(FOLLOW_rule__XAnnotation__ValueAssignment_3_1_1_in_rule__XAnnotation__Alternatives_3_15603); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2668: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 { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2672:1: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) ) | ( ( rule__XAnnotationElementValueOrCommaList__Group_1__0 ) ) ) + int alt4=2; + alt4 = dfa4.predict(input); + switch (alt4) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2673:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2673:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2674:1: ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2675:1: ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2675:2: rule__XAnnotationElementValueOrCommaList__Group_0__0 + { + pushFollow(FOLLOW_rule__XAnnotationElementValueOrCommaList__Group_0__0_in_rule__XAnnotationElementValueOrCommaList__Alternatives5636); + rule__XAnnotationElementValueOrCommaList__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0()); + } + + } + + + } + break; + case 2 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2679:6: ( ( rule__XAnnotationElementValueOrCommaList__Group_1__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2679:6: ( ( rule__XAnnotationElementValueOrCommaList__Group_1__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2680:1: ( rule__XAnnotationElementValueOrCommaList__Group_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2681:1: ( rule__XAnnotationElementValueOrCommaList__Group_1__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2681:2: rule__XAnnotationElementValueOrCommaList__Group_1__0 + { + pushFollow(FOLLOW_rule__XAnnotationElementValueOrCommaList__Group_1__0_in_rule__XAnnotationElementValueOrCommaList__Alternatives5654); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2690:1: rule__XAnnotationElementValue__Alternatives : ( ( ( rule__XAnnotationElementValue__Group_0__0 ) ) | ( ruleXAnnotationOrExpression ) ); + public final void rule__XAnnotationElementValue__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2694:1: ( ( ( rule__XAnnotationElementValue__Group_0__0 ) ) | ( ruleXAnnotationOrExpression ) ) + int alt5=2; + alt5 = dfa5.predict(input); + switch (alt5) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2695:1: ( ( rule__XAnnotationElementValue__Group_0__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2695:1: ( ( rule__XAnnotationElementValue__Group_0__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2696:1: ( rule__XAnnotationElementValue__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2697:1: ( rule__XAnnotationElementValue__Group_0__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2697:2: rule__XAnnotationElementValue__Group_0__0 + { + pushFollow(FOLLOW_rule__XAnnotationElementValue__Group_0__0_in_rule__XAnnotationElementValue__Alternatives5687); + rule__XAnnotationElementValue__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0()); + } + + } + + + } + break; + case 2 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2701:6: ( ruleXAnnotationOrExpression ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2701:6: ( ruleXAnnotationOrExpression ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2702:1: ruleXAnnotationOrExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_ruleXAnnotationOrExpression_in_rule__XAnnotationElementValue__Alternatives5705); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2712:1: rule__XAnnotationOrExpression__Alternatives : ( ( ruleXAnnotation ) | ( ruleXExpression ) ); + public final void rule__XAnnotationOrExpression__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2716:1: ( ( ruleXAnnotation ) | ( ruleXExpression ) ) + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0==76) ) { + alt6=1; + } + else if ( ((LA6_0>=RULE_ID && LA6_0<=RULE_STRING)||LA6_0==27||(LA6_0>=34 && LA6_0<=35)||LA6_0==40||(LA6_0>=45 && LA6_0<=50)||LA6_0==60||LA6_0==77||(LA6_0>=81 && LA6_0<=82)||LA6_0==86||LA6_0==88||(LA6_0>=91 && LA6_0<=99)||LA6_0==101||LA6_0==109) ) { + alt6=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 6, 0, input); + + throw nvae; + } + switch (alt6) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2717:1: ( ruleXAnnotation ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2717:1: ( ruleXAnnotation ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2718:1: ruleXAnnotation + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0()); + } + pushFollow(FOLLOW_ruleXAnnotation_in_rule__XAnnotationOrExpression__Alternatives5737); + ruleXAnnotation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0()); + } + + } + + + } + break; + case 2 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2723:6: ( ruleXExpression ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2723:6: ( ruleXExpression ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2724:1: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_ruleXExpression_in_rule__XAnnotationOrExpression__Alternatives5754); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2734: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 { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2738:1: ( ( ( rule__XAssignment__Group_0__0 ) ) | ( ( rule__XAssignment__Group_1__0 ) ) ) + int alt7=2; + switch ( input.LA(1) ) { + case RULE_ID: + { + int LA7_1 = input.LA(2); + + if ( (LA7_1==EOF||(LA7_1>=RULE_ID && LA7_1<=RULE_STRING)||(LA7_1>=14 && LA7_1<=50)||(LA7_1>=60 && LA7_1<=61)||LA7_1==73||(LA7_1>=77 && LA7_1<=102)||(LA7_1>=105 && LA7_1<=106)||(LA7_1>=108 && LA7_1<=109)) ) { + alt7=2; + } + else if ( (LA7_1==13) ) { + alt7=1; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 7, 1, input); + + throw nvae; + } + } + break; + case 45: + { + int LA7_2 = input.LA(2); + + if ( (LA7_2==13) ) { + alt7=1; + } + else if ( (LA7_2==EOF||(LA7_2>=RULE_ID && LA7_2<=RULE_STRING)||(LA7_2>=14 && LA7_2<=50)||(LA7_2>=60 && LA7_2<=61)||LA7_2==73||(LA7_2>=77 && LA7_2<=102)||(LA7_2>=105 && LA7_2<=106)||(LA7_2>=108 && LA7_2<=109)) ) { + alt7=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 7, 2, input); + + throw nvae; + } + } + break; + case 46: + { + int LA7_3 = input.LA(2); + + if ( (LA7_3==EOF||(LA7_3>=RULE_ID && LA7_3<=RULE_STRING)||(LA7_3>=14 && LA7_3<=50)||(LA7_3>=60 && LA7_3<=61)||LA7_3==73||(LA7_3>=77 && LA7_3<=102)||(LA7_3>=105 && LA7_3<=106)||(LA7_3>=108 && LA7_3<=109)) ) { + alt7=2; + } + else if ( (LA7_3==13) ) { + alt7=1; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 7, 3, input); + + throw nvae; + } + } + break; + case 47: + { + int LA7_4 = input.LA(2); + + if ( (LA7_4==13) ) { + alt7=1; + } + else if ( (LA7_4==EOF||(LA7_4>=RULE_ID && LA7_4<=RULE_STRING)||(LA7_4>=14 && LA7_4<=50)||(LA7_4>=60 && LA7_4<=61)||LA7_4==73||(LA7_4>=77 && LA7_4<=102)||(LA7_4>=105 && LA7_4<=106)||(LA7_4>=108 && LA7_4<=109)) ) { + alt7=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 7, 4, input); + + throw nvae; + } + } + break; + case 48: + { + int LA7_5 = input.LA(2); + + if ( (LA7_5==EOF||(LA7_5>=RULE_ID && LA7_5<=RULE_STRING)||(LA7_5>=14 && LA7_5<=50)||(LA7_5>=60 && LA7_5<=61)||LA7_5==73||(LA7_5>=77 && LA7_5<=102)||(LA7_5>=105 && LA7_5<=106)||(LA7_5>=108 && LA7_5<=109)) ) { + alt7=2; + } + else if ( (LA7_5==13) ) { + alt7=1; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 7, 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 60: + case 77: + case 81: + case 82: + case 86: + case 88: + case 91: + case 92: + case 93: + case 94: + case 95: + case 96: + case 97: + case 98: + case 99: + case 101: + case 109: + { + alt7=2; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 7, 0, input); + + throw nvae; + } + + switch (alt7) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2739:1: ( ( rule__XAssignment__Group_0__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2739:1: ( ( rule__XAssignment__Group_0__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2740:1: ( rule__XAssignment__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getGroup_0()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2741:1: ( rule__XAssignment__Group_0__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2741:2: rule__XAssignment__Group_0__0 + { + pushFollow(FOLLOW_rule__XAssignment__Group_0__0_in_rule__XAssignment__Alternatives5786); + rule__XAssignment__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getGroup_0()); + } + + } + + + } + break; + case 2 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2745:6: ( ( rule__XAssignment__Group_1__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2745:6: ( ( rule__XAssignment__Group_1__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2746:1: ( rule__XAssignment__Group_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getGroup_1()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2747:1: ( rule__XAssignment__Group_1__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2747:2: rule__XAssignment__Group_1__0 + { + pushFollow(FOLLOW_rule__XAssignment__Group_1__0_in_rule__XAssignment__Alternatives5804); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2756: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 { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2760:1: ( ( '+=' ) | ( '-=' ) | ( '*=' ) | ( '/=' ) | ( '%=' ) | ( ( rule__OpMultiAssign__Group_5__0 ) ) | ( ( rule__OpMultiAssign__Group_6__0 ) ) ) + int alt8=7; + switch ( input.LA(1) ) { + case 16: + { + alt8=1; + } + break; + case 17: + { + alt8=2; + } + break; + case 18: + { + alt8=3; + } + break; + case 19: + { + alt8=4; + } + break; + case 20: + { + alt8=5; + } + break; + case 27: + { + alt8=6; + } + break; + case 26: + { + alt8=7; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 8, 0, input); + + throw nvae; + } + + switch (alt8) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2761:1: ( '+=' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2761:1: ( '+=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2762:1: '+=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); + } + match(input,16,FOLLOW_16_in_rule__OpMultiAssign__Alternatives5838); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); + } + + } + + + } + break; + case 2 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2769:6: ( '-=' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2769:6: ( '-=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2770:1: '-=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); + } + match(input,17,FOLLOW_17_in_rule__OpMultiAssign__Alternatives5858); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); + } + + } + + + } + break; + case 3 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2777:6: ( '*=' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2777:6: ( '*=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2778:1: '*=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); + } + match(input,18,FOLLOW_18_in_rule__OpMultiAssign__Alternatives5878); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); + } + + } + + + } + break; + case 4 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2785:6: ( '/=' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2785:6: ( '/=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2786:1: '/=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); + } + match(input,19,FOLLOW_19_in_rule__OpMultiAssign__Alternatives5898); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); + } + + } + + + } + break; + case 5 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2793:6: ( '%=' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2793:6: ( '%=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2794:1: '%=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); + } + match(input,20,FOLLOW_20_in_rule__OpMultiAssign__Alternatives5918); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); + } + + } + + + } + break; + case 6 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2801:6: ( ( rule__OpMultiAssign__Group_5__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2801:6: ( ( rule__OpMultiAssign__Group_5__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2802:1: ( rule__OpMultiAssign__Group_5__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getGroup_5()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2803:1: ( rule__OpMultiAssign__Group_5__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2803:2: rule__OpMultiAssign__Group_5__0 + { + pushFollow(FOLLOW_rule__OpMultiAssign__Group_5__0_in_rule__OpMultiAssign__Alternatives5937); + rule__OpMultiAssign__Group_5__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getGroup_5()); + } + + } + + + } + break; + case 7 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2807:6: ( ( rule__OpMultiAssign__Group_6__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2807:6: ( ( rule__OpMultiAssign__Group_6__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2808:1: ( rule__OpMultiAssign__Group_6__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getGroup_6()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2809:1: ( rule__OpMultiAssign__Group_6__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2809:2: rule__OpMultiAssign__Group_6__0 + { + pushFollow(FOLLOW_rule__OpMultiAssign__Group_6__0_in_rule__OpMultiAssign__Alternatives5955); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2818:1: rule__OpEquality__Alternatives : ( ( '==' ) | ( '!=' ) | ( '===' ) | ( '!==' ) ); + public final void rule__OpEquality__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2822:1: ( ( '==' ) | ( '!=' ) | ( '===' ) | ( '!==' ) ) + int alt9=4; + switch ( input.LA(1) ) { + case 21: + { + alt9=1; + } + break; + case 22: + { + alt9=2; + } + break; + case 23: + { + alt9=3; + } + break; + case 24: + { + alt9=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 9, 0, input); + + throw nvae; + } + + switch (alt9) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2823:1: ( '==' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2823:1: ( '==' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2824:1: '==' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); + } + match(input,21,FOLLOW_21_in_rule__OpEquality__Alternatives5989); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); + } + + } + + + } + break; + case 2 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2831:6: ( '!=' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2831:6: ( '!=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2832:1: '!=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); + } + match(input,22,FOLLOW_22_in_rule__OpEquality__Alternatives6009); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); + } + + } + + + } + break; + case 3 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2839:6: ( '===' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2839:6: ( '===' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2840:1: '===' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); + } + match(input,23,FOLLOW_23_in_rule__OpEquality__Alternatives6029); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); + } + + } + + + } + break; + case 4 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2847:6: ( '!==' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2847:6: ( '!==' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2848:1: '!==' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); + } + match(input,24,FOLLOW_24_in_rule__OpEquality__Alternatives6049); 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2860: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 { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2864:1: ( ( ( rule__XRelationalExpression__Group_1_0__0 ) ) | ( ( rule__XRelationalExpression__Group_1_1__0 ) ) ) + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0==83) ) { + alt10=1; + } + else if ( ((LA10_0>=25 && LA10_0<=27)) ) { + alt10=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 10, 0, input); + + throw nvae; + } + switch (alt10) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2865:1: ( ( rule__XRelationalExpression__Group_1_0__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2865:1: ( ( rule__XRelationalExpression__Group_1_0__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2866:1: ( rule__XRelationalExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2867:1: ( rule__XRelationalExpression__Group_1_0__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2867:2: rule__XRelationalExpression__Group_1_0__0 + { + pushFollow(FOLLOW_rule__XRelationalExpression__Group_1_0__0_in_rule__XRelationalExpression__Alternatives_16083); + 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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2871:6: ( ( rule__XRelationalExpression__Group_1_1__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2871:6: ( ( rule__XRelationalExpression__Group_1_1__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2872:1: ( rule__XRelationalExpression__Group_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2873:1: ( rule__XRelationalExpression__Group_1_1__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2873:2: rule__XRelationalExpression__Group_1_1__0 + { + pushFollow(FOLLOW_rule__XRelationalExpression__Group_1_1__0_in_rule__XRelationalExpression__Alternatives_16101); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2882:1: rule__OpCompare__Alternatives : ( ( '>=' ) | ( ( rule__OpCompare__Group_1__0 ) ) | ( '>' ) | ( '<' ) ); + public final void rule__OpCompare__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2886:1: ( ( '>=' ) | ( ( rule__OpCompare__Group_1__0 ) ) | ( '>' ) | ( '<' ) ) + int alt11=4; + switch ( input.LA(1) ) { + case 25: + { + alt11=1; + } + break; + case 27: + { + int LA11_2 = input.LA(2); + + if ( (LA11_2==13) ) { + alt11=2; + } + else if ( (LA11_2==EOF||(LA11_2>=RULE_ID && LA11_2<=RULE_STRING)||LA11_2==27||(LA11_2>=34 && LA11_2<=35)||LA11_2==40||(LA11_2>=45 && LA11_2<=50)||LA11_2==60||LA11_2==77||(LA11_2>=81 && LA11_2<=82)||LA11_2==86||LA11_2==88||(LA11_2>=91 && LA11_2<=99)||LA11_2==101||LA11_2==109) ) { + alt11=4; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 11, 2, input); + + throw nvae; + } + } + break; + case 26: + { + alt11=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 11, 0, input); + + throw nvae; + } + + switch (alt11) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2887:1: ( '>=' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2887:1: ( '>=' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2888:1: '>=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); + } + match(input,25,FOLLOW_25_in_rule__OpCompare__Alternatives6135); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); + } + + } + + + } + break; + case 2 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2895:6: ( ( rule__OpCompare__Group_1__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2895:6: ( ( rule__OpCompare__Group_1__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2896:1: ( rule__OpCompare__Group_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getGroup_1()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2897:1: ( rule__OpCompare__Group_1__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2897:2: rule__OpCompare__Group_1__0 + { + pushFollow(FOLLOW_rule__OpCompare__Group_1__0_in_rule__OpCompare__Alternatives6154); + rule__OpCompare__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getGroup_1()); + } + + } + + + } + break; + case 3 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2901:6: ( '>' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2901:6: ( '>' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2902:1: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); + } + match(input,26,FOLLOW_26_in_rule__OpCompare__Alternatives6173); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); + } + + } + + + } + break; + case 4 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2909:6: ( '<' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2909:6: ( '<' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2910:1: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); + } + match(input,27,FOLLOW_27_in_rule__OpCompare__Alternatives6193); 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2922: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 { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2926:1: ( ( '->' ) | ( '..<' ) | ( ( rule__OpOther__Group_2__0 ) ) | ( '..' ) | ( '=>' ) | ( ( rule__OpOther__Group_5__0 ) ) | ( ( rule__OpOther__Group_6__0 ) ) | ( '<>' ) | ( '?:' ) ) + int alt12=9; + alt12 = dfa12.predict(input); + switch (alt12) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2927:1: ( '->' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2927:1: ( '->' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2928:1: '->' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); + } + match(input,28,FOLLOW_28_in_rule__OpOther__Alternatives6228); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); + } + + } + + + } + break; + case 2 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2935:6: ( '..<' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2935:6: ( '..<' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2936:1: '..<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); + } + match(input,29,FOLLOW_29_in_rule__OpOther__Alternatives6248); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); + } + + } + + + } + break; + case 3 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2943:6: ( ( rule__OpOther__Group_2__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2943:6: ( ( rule__OpOther__Group_2__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2944:1: ( rule__OpOther__Group_2__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_2()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2945:1: ( rule__OpOther__Group_2__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2945:2: rule__OpOther__Group_2__0 + { + pushFollow(FOLLOW_rule__OpOther__Group_2__0_in_rule__OpOther__Alternatives6267); + rule__OpOther__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_2()); + } + + } + + + } + break; + case 4 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2949:6: ( '..' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2949:6: ( '..' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2950:1: '..' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); + } + match(input,30,FOLLOW_30_in_rule__OpOther__Alternatives6286); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); + } + + } + + + } + break; + case 5 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2957:6: ( '=>' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2957:6: ( '=>' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2958:1: '=>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); + } + match(input,31,FOLLOW_31_in_rule__OpOther__Alternatives6306); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); + } + + } + + + } + break; + case 6 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2965:6: ( ( rule__OpOther__Group_5__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2965:6: ( ( rule__OpOther__Group_5__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2966:1: ( rule__OpOther__Group_5__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_5()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2967:1: ( rule__OpOther__Group_5__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2967:2: rule__OpOther__Group_5__0 + { + pushFollow(FOLLOW_rule__OpOther__Group_5__0_in_rule__OpOther__Alternatives6325); + rule__OpOther__Group_5__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_5()); + } + + } + + + } + break; + case 7 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2971:6: ( ( rule__OpOther__Group_6__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2971:6: ( ( rule__OpOther__Group_6__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2972:1: ( rule__OpOther__Group_6__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_6()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2973:1: ( rule__OpOther__Group_6__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2973:2: rule__OpOther__Group_6__0 + { + pushFollow(FOLLOW_rule__OpOther__Group_6__0_in_rule__OpOther__Alternatives6343); + rule__OpOther__Group_6__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_6()); + } + + } + + + } + break; + case 8 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2977:6: ( '<>' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2977:6: ( '<>' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2978:1: '<>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); + } + match(input,32,FOLLOW_32_in_rule__OpOther__Alternatives6362); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); + } + + } + + + } + break; + case 9 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2985:6: ( '?:' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2985:6: ( '?:' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2986:1: '?:' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); + } + match(input,33,FOLLOW_33_in_rule__OpOther__Alternatives6382); 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:2998: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 { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3002:1: ( ( ( rule__OpOther__Group_5_1_0__0 ) ) | ( '>' ) ) + int alt13=2; + int LA13_0 = input.LA(1); + + if ( (LA13_0==26) ) { + int LA13_1 = input.LA(2); + + if ( (LA13_1==26) ) { + alt13=1; + } + else if ( (LA13_1==EOF||(LA13_1>=RULE_ID && LA13_1<=RULE_STRING)||LA13_1==27||(LA13_1>=34 && LA13_1<=35)||LA13_1==40||(LA13_1>=45 && LA13_1<=50)||LA13_1==60||LA13_1==77||(LA13_1>=81 && LA13_1<=82)||LA13_1==86||LA13_1==88||(LA13_1>=91 && LA13_1<=99)||LA13_1==101||LA13_1==109) ) { + alt13=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 13, 1, input); + + throw nvae; + } + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 13, 0, input); + + throw nvae; + } + switch (alt13) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3003:1: ( ( rule__OpOther__Group_5_1_0__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3003:1: ( ( rule__OpOther__Group_5_1_0__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3004:1: ( rule__OpOther__Group_5_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3005:1: ( rule__OpOther__Group_5_1_0__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3005:2: rule__OpOther__Group_5_1_0__0 + { + pushFollow(FOLLOW_rule__OpOther__Group_5_1_0__0_in_rule__OpOther__Alternatives_5_16416); + 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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3009:6: ( '>' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3009:6: ( '>' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3010:1: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); + } + match(input,26,FOLLOW_26_in_rule__OpOther__Alternatives_5_16435); 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3022: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 { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3026:1: ( ( ( rule__OpOther__Group_6_1_0__0 ) ) | ( '<' ) | ( '=>' ) ) + int alt14=3; + int LA14_0 = input.LA(1); + + if ( (LA14_0==27) ) { + int LA14_1 = input.LA(2); + + if ( (synpred30_InternalStrategyDSL()) ) { + alt14=1; + } + else if ( (synpred31_InternalStrategyDSL()) ) { + alt14=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 14, 1, input); + + throw nvae; + } + } + else if ( (LA14_0==31) ) { + alt14=3; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 14, 0, input); + + throw nvae; + } + switch (alt14) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3027:1: ( ( rule__OpOther__Group_6_1_0__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3027:1: ( ( rule__OpOther__Group_6_1_0__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3028:1: ( rule__OpOther__Group_6_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3029:1: ( rule__OpOther__Group_6_1_0__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3029:2: rule__OpOther__Group_6_1_0__0 + { + pushFollow(FOLLOW_rule__OpOther__Group_6_1_0__0_in_rule__OpOther__Alternatives_6_16469); + 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 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3033:6: ( '<' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3033:6: ( '<' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3034:1: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); + } + match(input,27,FOLLOW_27_in_rule__OpOther__Alternatives_6_16488); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); + } + + } + + + } + break; + case 3 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3041:6: ( '=>' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3041:6: ( '=>' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3042:1: '=>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); + } + match(input,31,FOLLOW_31_in_rule__OpOther__Alternatives_6_16508); 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3054:1: rule__OpAdd__Alternatives : ( ( '+' ) | ( '-' ) ); + public final void rule__OpAdd__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3058:1: ( ( '+' ) | ( '-' ) ) + int alt15=2; + int LA15_0 = input.LA(1); + + if ( (LA15_0==34) ) { + alt15=1; + } + else if ( (LA15_0==35) ) { + alt15=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 15, 0, input); + + throw nvae; + } + switch (alt15) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3059:1: ( '+' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3059:1: ( '+' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3060:1: '+' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); + } + match(input,34,FOLLOW_34_in_rule__OpAdd__Alternatives6543); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); + } + + } + + + } + break; + case 2 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3067:6: ( '-' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3067:6: ( '-' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3068:1: '-' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); + } + match(input,35,FOLLOW_35_in_rule__OpAdd__Alternatives6563); 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3080:1: rule__OpMulti__Alternatives : ( ( '*' ) | ( '**' ) | ( '/' ) | ( '%' ) ); + public final void rule__OpMulti__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3084:1: ( ( '*' ) | ( '**' ) | ( '/' ) | ( '%' ) ) + int alt16=4; + switch ( input.LA(1) ) { + case 36: + { + alt16=1; + } + break; + case 37: + { + alt16=2; + } + break; + case 38: + { + alt16=3; + } + break; + case 39: + { + alt16=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 16, 0, input); + + throw nvae; + } + + switch (alt16) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3085:1: ( '*' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3085:1: ( '*' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3086:1: '*' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); + } + match(input,36,FOLLOW_36_in_rule__OpMulti__Alternatives6598); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); + } + + } + + + } + break; + case 2 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3093:6: ( '**' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3093:6: ( '**' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3094:1: '**' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); + } + match(input,37,FOLLOW_37_in_rule__OpMulti__Alternatives6618); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); + } + + } + + + } + break; + case 3 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3101:6: ( '/' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3101:6: ( '/' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3102:1: '/' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); + } + match(input,38,FOLLOW_38_in_rule__OpMulti__Alternatives6638); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); + } + + } + + + } + break; + case 4 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3109:6: ( '%' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3109:6: ( '%' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3110:1: '%' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); + } + match(input,39,FOLLOW_39_in_rule__OpMulti__Alternatives6658); 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3122:1: rule__XUnaryOperation__Alternatives : ( ( ( rule__XUnaryOperation__Group_0__0 ) ) | ( ruleXCastedExpression ) ); + public final void rule__XUnaryOperation__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3126:1: ( ( ( rule__XUnaryOperation__Group_0__0 ) ) | ( ruleXCastedExpression ) ) + int alt17=2; + int LA17_0 = input.LA(1); + + if ( ((LA17_0>=34 && LA17_0<=35)||LA17_0==40) ) { + alt17=1; + } + else if ( ((LA17_0>=RULE_ID && LA17_0<=RULE_STRING)||LA17_0==27||(LA17_0>=45 && LA17_0<=50)||LA17_0==60||LA17_0==77||(LA17_0>=81 && LA17_0<=82)||LA17_0==86||LA17_0==88||(LA17_0>=91 && LA17_0<=99)||LA17_0==101||LA17_0==109) ) { + alt17=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 17, 0, input); + + throw nvae; + } + switch (alt17) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3127:1: ( ( rule__XUnaryOperation__Group_0__0 ) ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3127:1: ( ( rule__XUnaryOperation__Group_0__0 ) ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3128:1: ( rule__XUnaryOperation__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getGroup_0()); + } + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3129:1: ( rule__XUnaryOperation__Group_0__0 ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3129:2: rule__XUnaryOperation__Group_0__0 + { + pushFollow(FOLLOW_rule__XUnaryOperation__Group_0__0_in_rule__XUnaryOperation__Alternatives6692); + rule__XUnaryOperation__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getGroup_0()); + } + + } + + + } + break; + case 2 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3133:6: ( ruleXCastedExpression ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3133:6: ( ruleXCastedExpression ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3134:1: ruleXCastedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_ruleXCastedExpression_in_rule__XUnaryOperation__Alternatives6710); + 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3144:1: rule__OpUnary__Alternatives : ( ( '!' ) | ( '-' ) | ( '+' ) ); + public final void rule__OpUnary__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3148:1: ( ( '!' ) | ( '-' ) | ( '+' ) ) + int alt18=3; + switch ( input.LA(1) ) { + case 40: + { + alt18=1; + } + break; + case 35: + { + alt18=2; + } + break; + case 34: + { + alt18=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 18, 0, input); + + throw nvae; + } + + switch (alt18) { + case 1 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3149:1: ( '!' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3149:1: ( '!' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3150:1: '!' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); + } + match(input,40,FOLLOW_40_in_rule__OpUnary__Alternatives6743); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); + } + + } + + + } + break; + case 2 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3157:6: ( '-' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3157:6: ( '-' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3158:1: '-' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); + } + match(input,35,FOLLOW_35_in_rule__OpUnary__Alternatives6763); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); + } + + } + + + } + break; + case 3 : + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3165:6: ( '+' ) + { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3165:6: ( '+' ) + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3166:1: '+' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); + } + match(input,34,FOLLOW_34_in_rule__OpUnary__Alternatives6783); 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" + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3178:1: rule__OpPostfix__Alternatives : ( ( '++' ) | ( '--' ) ); + public final void rule__OpPostfix__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // ../org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/antlr/internal/InternalStrategyDSL.g:3182:1: ( ( '++' ) | ( '--' ) ) + int alt19=2; + int LA19_0 = input.LA(1); diff --git a/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/internal/StrategyDSLActivator.java b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/internal/StrategyDSLActivator.java new file mode 100644 index 0000000..d49e484 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src-gen/org/eclipse/osbp/xtext/strategy/ui/internal/StrategyDSLActivator.java @@ -0,0 +1,105 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + */ +package org.eclipse.osbp.xtext.strategy.ui.internal; + +import java.util.Collections; +import java.util.Map; + +import org.apache.log4j.Logger; +import org.eclipse.ui.plugin.AbstractUIPlugin; +import org.eclipse.xtext.ui.shared.SharedStateModule; +import org.eclipse.xtext.util.Modules2; +import org.osgi.framework.BundleContext; + +import com.google.common.collect.Maps; +import com.google.inject.Guice; +import com.google.inject.Injector; +import com.google.inject.Module; + +/** + * This class was generated. Customizations should only happen in a newly + * introduced subclass. + */ +public class StrategyDSLActivator extends AbstractUIPlugin { + + public static final String ORG_ECLIPSE_OSBP_XTEXT_STRATEGY_STRATEGYDSL = "org.eclipse.osbp.xtext.strategy.StrategyDSL"; + + private static final Logger logger = Logger.getLogger(StrategyDSLActivator.class); + + private static StrategyDSLActivator 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 StrategyDSLActivator 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_STRATEGY_STRATEGYDSL.equals(grammar)) { + return new org.eclipse.osbp.xtext.strategy.StrategyDSLRuntimeModule(); + } + + throw new IllegalArgumentException(grammar); + } + + protected Module getUiModule(String grammar) { + if (ORG_ECLIPSE_OSBP_XTEXT_STRATEGY_STRATEGYDSL.equals(grammar)) { + return new org.eclipse.osbp.xtext.strategy.ui.StrategyDSLUiModule(this); + } + + throw new IllegalArgumentException(grammar); + } + + protected Module getSharedStateModule() { + return new SharedStateModule(); + } + +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLDocumentationTranslator.java b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLDocumentationTranslator.java new file mode 100644 index 0000000..d61c133 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLDocumentationTranslator.java @@ -0,0 +1,46 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + */ + +package org.eclipse.osbp.xtext.strategy.ui; + +import java.util.ResourceBundle; + +import org.eclipse.osbp.utils.constants.GeneratorConstants; +import org.eclipse.osbp.xtext.basic.ui.BasicDSLDocumentationTranslator; + +/** + * The Class DatamartDSLDocumentationTranslator. + */ +public class StrategyDSLDocumentationTranslator extends BasicDSLDocumentationTranslator { + + /** The instance. */ + private static StrategyDSLDocumentationTranslator INSTANCE = new StrategyDSLDocumentationTranslator(); + + /** + * Instance. + * + * @return the basic dsl documentation translator + */ + public static BasicDSLDocumentationTranslator instance() { + return INSTANCE; + } + + /* (non-Javadoc) + * @see org.eclipse.osbp.xtext.basic.ui.BasicDSLDocumentationTranslator#getResourceBundle() + */ + @Override + protected ResourceBundle getResourceBundle() { + return java.util.ResourceBundle.getBundle(GeneratorConstants.I18N_RESOURCE_FULL_BUNDLE_NAME, getLocale(), getClass().getClassLoader()); + } +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLEObjectHover.java b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLEObjectHover.java new file mode 100644 index 0000000..a3de5ad --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLEObjectHover.java @@ -0,0 +1,33 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + */ + +package org.eclipse.osbp.xtext.strategy.ui; + +import org.eclipse.xtext.ui.editor.hover.IEObjectHoverProvider; + +import org.eclipse.osbp.xtext.basic.ui.BasicDSLEObjectHover; + +/** + * The Class DatamartDSLEObjectHover. + */ +public class StrategyDSLEObjectHover extends BasicDSLEObjectHover { + + /* (non-Javadoc) + * @see org.eclipse.osbp.xtext.basic.ui.BasicDSLEObjectHover#getHoverProvider() + */ + @Override + public IEObjectHoverProvider getHoverProvider() { + return StrategyDSLEObjectHoverProvider.instance(); + } +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLEObjectHoverDocumentationProvider.java b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLEObjectHoverDocumentationProvider.java new file mode 100644 index 0000000..ec0a3a4 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLEObjectHoverDocumentationProvider.java @@ -0,0 +1,50 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + */ + +package org.eclipse.osbp.xtext.strategy.ui; + +import org.eclipse.osbp.xtext.basic.ui.BasicDSLDocumentationTranslator; +import org.eclipse.osbp.xtext.basic.ui.BasicDSLEObjectHoverDocumentationProvider; + +/** + * The Class DatamartDSLEObjectHoverDocumentationProvider. + */ +public class StrategyDSLEObjectHoverDocumentationProvider extends BasicDSLEObjectHoverDocumentationProvider { + + /** The instance. */ + private static StrategyDSLEObjectHoverDocumentationProvider INSTANCE; + + /** Instance. + * + * @return the datamart dsle object hover documentation provider + */ + public static StrategyDSLEObjectHoverDocumentationProvider instance() { + return INSTANCE; + } + + /** Instantiates a new datamart dsle object hover documentation provider. + */ + public StrategyDSLEObjectHoverDocumentationProvider() { + super(); + INSTANCE = this; + } + + /* (non-Javadoc) + * @see org.eclipse.osbp.xtext.basic.ui.BasicDSLEObjectHoverDocumentationProvider#getTranslator() + */ + @Override + protected BasicDSLDocumentationTranslator getTranslator() { + return StrategyDSLDocumentationTranslator.instance(); + } +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLEObjectHoverProvider.java b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLEObjectHoverProvider.java new file mode 100644 index 0000000..1501066 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLEObjectHoverProvider.java @@ -0,0 +1,51 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + */ + +package org.eclipse.osbp.xtext.strategy.ui; + +import org.eclipse.xtext.ui.editor.hover.html.IEObjectHoverDocumentationProvider; + +import org.eclipse.osbp.xtext.basic.ui.BasicDSLEObjectHoverProvider; + +/** + * The Class DatamartDSLEObjectHoverProvider. + */ +public class StrategyDSLEObjectHoverProvider extends BasicDSLEObjectHoverProvider { + + /** The instance. */ + private static StrategyDSLEObjectHoverProvider INSTANCE; + + /** Instance. + * + * @return the datamart dsle object hover provider + */ + public static StrategyDSLEObjectHoverProvider instance() { + return INSTANCE; + } + + /** Instantiates a new datamart dsle object hover provider. + */ + public StrategyDSLEObjectHoverProvider() { + super(); + INSTANCE = this; + } + + /* (non-Javadoc) + * @see org.eclipse.osbp.xtext.basic.ui.BasicDSLEObjectHoverProvider#getDocumentationHoverProvider() + */ + @Override + public IEObjectHoverDocumentationProvider getDocumentationHoverProvider() { + return StrategyDSLEObjectHoverDocumentationProvider.instance(); + } +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLUiModule.java b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLUiModule.java new file mode 100644 index 0000000..190b5e0 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/StrategyDSLUiModule.java @@ -0,0 +1,58 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + */ +package org.eclipse.osbp.xtext.strategy.ui; + +import org.eclipse.osbp.xtext.basic.ui.BasicDSLUiModuleHelper; +import org.eclipse.ui.plugin.AbstractUIPlugin; +import org.eclipse.xtext.ui.editor.hover.IEObjectHover; +import org.eclipse.xtext.ui.editor.hover.IEObjectHoverProvider; +import org.eclipse.xtext.ui.editor.hover.html.IEObjectHoverDocumentationProvider; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Use this class to register components to be used within the IDE. + */ +public class StrategyDSLUiModule extends + org.eclipse.osbp.xtext.strategy.ui.AbstractStrategyDSLUiModule { + /** The logger. */ + private static Logger LOGGER = LoggerFactory + .getLogger(StrategyDSLUiModule.class); + + /** + * Instantiates a new strategy DSL ui module. + * + * @param plugin + * the plugin + */ + public StrategyDSLUiModule(AbstractUIPlugin plugin) { + super(plugin); + BasicDSLUiModuleHelper.unitTestTemplates(plugin, LOGGER); + } + + @Override + public Class<? extends IEObjectHover> bindIEObjectHover() { + return StrategyDSLEObjectHover.class; + } + + @Override + public Class<? extends IEObjectHoverProvider> bindIEObjectHoverProvider() { + return StrategyDSLEObjectHoverProvider.class; + } + + @Override + public Class<? extends IEObjectHoverDocumentationProvider> bindIEObjectHoverDocumentationProvider() { + return StrategyDSLEObjectHoverDocumentationProvider.class; + } +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/contentassist/StrategyDSLProposalProvider.xtend b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/contentassist/StrategyDSLProposalProvider.xtend new file mode 100644 index 0000000..05f8ea9 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/contentassist/StrategyDSLProposalProvider.xtend @@ -0,0 +1,54 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + * + * This copyright notice shows up in the generated Java code + * + */ + +package org.eclipse.osbp.xtext.strategy.ui.contentassist + +import com.google.inject.Inject +import org.eclipse.emf.ecore.EObject +import org.eclipse.osbp.xtext.basic.ui.contentassist.BasicDSLProposalProviderHelper +import org.eclipse.xtext.Keyword +import org.eclipse.xtext.RuleCall +import org.eclipse.xtext.common.ui.contentassist.TerminalsProposalProvider +import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext +import org.eclipse.xtext.ui.editor.contentassist.ICompletionProposalAcceptor + +/** + * see http://www.eclipse.org/Xtext/documentation.html#contentAssist on how to customize content assistant + */ +class StrategyDSLProposalProvider extends AbstractStrategyDSLProposalProvider { + @Inject TerminalsProposalProvider provider + @Inject BasicDSLProposalProviderHelper providerHelper + + /** + * This override will enable 1 length non letter characters as keyword. + */ + override protected boolean isKeywordWorthyToPropose(Keyword keyword) { + true + } + + override public void complete_QualifiedName(EObject model, RuleCall ruleCall, ContentAssistContext context, + ICompletionProposalAcceptor acceptor) { + providerHelper.complete_PackageName(model, ruleCall, context, acceptor, this) + } + + // ------------------------ delegates to TerminalsProposalProvider ----------------- + override public void complete_ID(EObject model, RuleCall ruleCall, ContentAssistContext context, + ICompletionProposalAcceptor acceptor) { + provider.complete_ID(model, ruleCall, context, acceptor) + } + +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/labeling/StrategyDSLDescriptionLabelProvider.xtend b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/labeling/StrategyDSLDescriptionLabelProvider.xtend new file mode 100644 index 0000000..7b383e5 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/labeling/StrategyDSLDescriptionLabelProvider.xtend @@ -0,0 +1,38 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + * + * This copyright notice shows up in the generated Java code + * + */ + +package org.eclipse.osbp.xtext.strategy.ui.labeling + +//import org.eclipse.xtext.resource.IEObjectDescription + +/** + * Provides labels for a IEObjectDescriptions and IResourceDescriptions. + * + * see http://www.eclipse.org/Xtext/documentation.html#labelProvider + */ +class StrategyDSLDescriptionLabelProvider extends org.eclipse.xtext.ui.label.DefaultDescriptionLabelProvider { + + // 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.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/labeling/StrategyDSLLabelProvider.xtend b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/labeling/StrategyDSLLabelProvider.xtend new file mode 100644 index 0000000..0df4cab --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/labeling/StrategyDSLLabelProvider.xtend @@ -0,0 +1,73 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + * + * This copyright notice shows up in the generated Java code + * + */ + +package org.eclipse.osbp.xtext.strategy.ui.labeling + +import com.google.inject.Inject +import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider +import org.eclipse.osbp.xtext.strategy.FocusingEnhancer +import org.eclipse.osbp.xtext.strategy.FocusingStrategy +import org.eclipse.osbp.xtext.strategy.LayoutingStrategy +import org.eclipse.osbp.xtext.strategy.StrategyTarget +import org.eclipse.osbp.xtext.strategy.Strategy +import org.eclipse.osbp.xtext.strategy.StrategyDefault +import org.eclipse.osbp.xtext.strategy.StrategyModel +import org.eclipse.osbp.xtext.strategy.StrategyPackage +import org.eclipse.xtext.ui.label.DefaultEObjectLabelProvider +import org.eclipse.osbp.xtext.basic.ui.labeling.BasicDSLLabelProvider + +/** + * Provides labels for a EObjects. + * + * see http://www.eclipse.org/Xtext/documentation.html#labelProvider + */ +class StrategyDSLLabelProvider extends BasicDSLLabelProvider { + + @Inject + new(AdapterFactoryLabelProvider delegate) { + super(delegate); + } + + // Labels and icons can be computed like this: + + override text ( Object o ) { + switch (o) { + StrategyPackage : generateText( o, 'package' , (o as StrategyPackage ).name ) + Strategy : generateText( o, 'strategy model' ) + StrategyTarget : generateText( o, 'strategies' ) + LayoutingStrategy : generateText( o, 'layoutingStrategy', (o as LayoutingStrategy).name ) + FocusingStrategy : generateText( o, 'focusingStrategy' , (o as FocusingStrategy).name ) + FocusingEnhancer : generateText( o, 'focusingEnhancer' , (o as FocusingEnhancer).name ) + StrategyDefault : generateText( o, 'default' ) + default : super.text( o ) + } + } + + override image ( Object o ) { + switch (o) { + StrategyModel : getInternalImage( 'model.png', class) + StrategyPackage : getInternalImage( 'package.gif', class) + Strategy : getInternalImage( 'dsl_strategy.png', class) + StrategyTarget : getInternalImage( 'strategies.png', class) + LayoutingStrategy : getInternalImage( 'layout.png', class) + FocusingStrategy : getInternalImage( 'focus.png', class) + FocusingEnhancer : getInternalImage( 'focus-enhance.png', class) + StrategyDefault : getInternalImage( 'strategy-default.png', class) + default : super.image( o ) + } + } +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/outline/StrategyDSLOutlineTreeProvider.xtend b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/outline/StrategyDSLOutlineTreeProvider.xtend new file mode 100644 index 0000000..4fe8085 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/outline/StrategyDSLOutlineTreeProvider.xtend @@ -0,0 +1,27 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + * + * This copyright notice shows up in the generated Java code + * + */ + +package org.eclipse.osbp.xtext.strategy.ui.outline + +/** + * Customization of the default outline structure. + * + * see http://www.eclipse.org/Xtext/documentation.html#outline + */ +class StrategyDSLOutlineTreeProvider extends org.eclipse.xtext.ui.editor.outline.impl.DefaultOutlineTreeProvider { + +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/quickfix/StrategyDSLQuickfixProvider.xtend b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/quickfix/StrategyDSLQuickfixProvider.xtend new file mode 100644 index 0000000..bd794ed --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/src/org/eclipse/osbp/xtext/strategy/ui/quickfix/StrategyDSLQuickfixProvider.xtend @@ -0,0 +1,40 @@ +/** + * + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + * + * This copyright notice shows up in the generated Java code + * + */ + +package org.eclipse.osbp.xtext.strategy.ui.quickfix + +//import org.eclipse.xtext.ui.editor.quickfix.Fix +//import org.eclipse.xtext.ui.editor.quickfix.IssueResolutionAcceptor +//import org.eclipse.xtext.validation.Issue + +/** + * Custom quickfixes. + * + * see http://www.eclipse.org/Xtext/documentation.html#quickfixes + */ +class StrategyDSLQuickfixProvider extends org.eclipse.xtext.ui.editor.quickfix.DefaultQuickfixProvider { + +// @Fix(MyDslValidator::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.strategy.ui/xtend-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/StrategyDSLProposalProvider.java b/org.eclipse.osbp.xtext.strategy.ui/xtend-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/StrategyDSLProposalProvider.java new file mode 100644 index 0000000..0cec769 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/xtend-gen/org/eclipse/osbp/xtext/strategy/ui/contentassist/StrategyDSLProposalProvider.java @@ -0,0 +1,52 @@ +/** + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + * + * This copyright notice shows up in the generated Java code + */ +package org.eclipse.osbp.xtext.strategy.ui.contentassist; + +import com.google.inject.Inject; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.osbp.xtext.basic.ui.contentassist.BasicDSLProposalProviderHelper; +import org.eclipse.osbp.xtext.strategy.ui.contentassist.AbstractStrategyDSLProposalProvider; +import org.eclipse.xtext.Keyword; +import org.eclipse.xtext.RuleCall; +import org.eclipse.xtext.common.ui.contentassist.TerminalsProposalProvider; +import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext; +import org.eclipse.xtext.ui.editor.contentassist.ICompletionProposalAcceptor; + +/** + * see http://www.eclipse.org/Xtext/documentation.html#contentAssist on how to customize content assistant + */ +@SuppressWarnings("all") +public class StrategyDSLProposalProvider extends AbstractStrategyDSLProposalProvider { + @Inject + private TerminalsProposalProvider provider; + + @Inject + private BasicDSLProposalProviderHelper providerHelper; + + /** + * This override will enable 1 length non letter characters as keyword. + */ + protected boolean isKeywordWorthyToPropose(final Keyword keyword) { + return true; + } + + public void complete_QualifiedName(final EObject model, final RuleCall ruleCall, final ContentAssistContext context, final ICompletionProposalAcceptor acceptor) { + this.providerHelper.complete_PackageName(model, ruleCall, context, acceptor, this); + } + + public void complete_ID(final EObject model, final RuleCall ruleCall, final ContentAssistContext context, final ICompletionProposalAcceptor acceptor) { + this.provider.complete_ID(model, ruleCall, context, acceptor); + } +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/xtend-gen/org/eclipse/osbp/xtext/strategy/ui/labeling/StrategyDSLDescriptionLabelProvider.java b/org.eclipse.osbp.xtext.strategy.ui/xtend-gen/org/eclipse/osbp/xtext/strategy/ui/labeling/StrategyDSLDescriptionLabelProvider.java new file mode 100644 index 0000000..8be81f5 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/xtend-gen/org/eclipse/osbp/xtext/strategy/ui/labeling/StrategyDSLDescriptionLabelProvider.java @@ -0,0 +1,26 @@ +/** + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + * + * This copyright notice shows up in the generated Java code + */ +package org.eclipse.osbp.xtext.strategy.ui.labeling; + +import org.eclipse.xtext.ui.label.DefaultDescriptionLabelProvider; + +/** + * Provides labels for a IEObjectDescriptions and IResourceDescriptions. + * + * see http://www.eclipse.org/Xtext/documentation.html#labelProvider + */ +@SuppressWarnings("all") +public class StrategyDSLDescriptionLabelProvider extends DefaultDescriptionLabelProvider { +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/xtend-gen/org/eclipse/osbp/xtext/strategy/ui/labeling/StrategyDSLLabelProvider.java b/org.eclipse.osbp.xtext.strategy.ui/xtend-gen/org/eclipse/osbp/xtext/strategy/ui/labeling/StrategyDSLLabelProvider.java new file mode 100644 index 0000000..a396d1b --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/xtend-gen/org/eclipse/osbp/xtext/strategy/ui/labeling/StrategyDSLLabelProvider.java @@ -0,0 +1,160 @@ +/** + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + * + * This copyright notice shows up in the generated Java code + */ +package org.eclipse.osbp.xtext.strategy.ui.labeling; + +import com.google.inject.Inject; +import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider; +import org.eclipse.osbp.xtext.basic.ui.labeling.BasicDSLLabelProvider; +import org.eclipse.osbp.xtext.strategy.FocusingEnhancer; +import org.eclipse.osbp.xtext.strategy.FocusingStrategy; +import org.eclipse.osbp.xtext.strategy.LayoutingStrategy; +import org.eclipse.osbp.xtext.strategy.Strategy; +import org.eclipse.osbp.xtext.strategy.StrategyDefault; +import org.eclipse.osbp.xtext.strategy.StrategyModel; +import org.eclipse.osbp.xtext.strategy.StrategyPackage; +import org.eclipse.osbp.xtext.strategy.StrategyTarget; + +/** + * Provides labels for a EObjects. + * + * see http://www.eclipse.org/Xtext/documentation.html#labelProvider + */ +@SuppressWarnings("all") +public class StrategyDSLLabelProvider extends BasicDSLLabelProvider { + @Inject + public StrategyDSLLabelProvider(final AdapterFactoryLabelProvider delegate) { + super(delegate); + } + + public Object text(final Object o) { + Object _switchResult = null; + boolean _matched = false; + if (!_matched) { + if (o instanceof StrategyPackage) { + _matched=true; + String _name = ((StrategyPackage) o).getName(); + _switchResult = this.generateText(o, "package", _name); + } + } + if (!_matched) { + if (o instanceof Strategy) { + _matched=true; + _switchResult = this.generateText(o, "strategy model"); + } + } + if (!_matched) { + if (o instanceof StrategyTarget) { + _matched=true; + _switchResult = this.generateText(o, "strategies"); + } + } + if (!_matched) { + if (o instanceof LayoutingStrategy) { + _matched=true; + String _name = ((LayoutingStrategy) o).getName(); + _switchResult = this.generateText(o, "layoutingStrategy", _name); + } + } + if (!_matched) { + if (o instanceof FocusingStrategy) { + _matched=true; + String _name = ((FocusingStrategy) o).getName(); + _switchResult = this.generateText(o, "focusingStrategy", _name); + } + } + if (!_matched) { + if (o instanceof FocusingEnhancer) { + _matched=true; + String _name = ((FocusingEnhancer) o).getName(); + _switchResult = this.generateText(o, "focusingEnhancer", _name); + } + } + if (!_matched) { + if (o instanceof StrategyDefault) { + _matched=true; + _switchResult = this.generateText(o, "default"); + } + } + if (!_matched) { + _switchResult = super.text(o); + } + return _switchResult; + } + + public Object image(final Object o) { + Object _switchResult = null; + boolean _matched = false; + if (!_matched) { + if (o instanceof StrategyModel) { + _matched=true; + Class<? extends StrategyDSLLabelProvider> _class = this.getClass(); + _switchResult = this.getInternalImage("model.png", _class); + } + } + if (!_matched) { + if (o instanceof StrategyPackage) { + _matched=true; + Class<? extends StrategyDSLLabelProvider> _class = this.getClass(); + _switchResult = this.getInternalImage("package.gif", _class); + } + } + if (!_matched) { + if (o instanceof Strategy) { + _matched=true; + Class<? extends StrategyDSLLabelProvider> _class = this.getClass(); + _switchResult = this.getInternalImage("dsl_strategy.png", _class); + } + } + if (!_matched) { + if (o instanceof StrategyTarget) { + _matched=true; + Class<? extends StrategyDSLLabelProvider> _class = this.getClass(); + _switchResult = this.getInternalImage("strategies.png", _class); + } + } + if (!_matched) { + if (o instanceof LayoutingStrategy) { + _matched=true; + Class<? extends StrategyDSLLabelProvider> _class = this.getClass(); + _switchResult = this.getInternalImage("layout.png", _class); + } + } + if (!_matched) { + if (o instanceof FocusingStrategy) { + _matched=true; + Class<? extends StrategyDSLLabelProvider> _class = this.getClass(); + _switchResult = this.getInternalImage("focus.png", _class); + } + } + if (!_matched) { + if (o instanceof FocusingEnhancer) { + _matched=true; + Class<? extends StrategyDSLLabelProvider> _class = this.getClass(); + _switchResult = this.getInternalImage("focus-enhance.png", _class); + } + } + if (!_matched) { + if (o instanceof StrategyDefault) { + _matched=true; + Class<? extends StrategyDSLLabelProvider> _class = this.getClass(); + _switchResult = this.getInternalImage("strategy-default.png", _class); + } + } + if (!_matched) { + _switchResult = super.image(o); + } + return _switchResult; + } +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/xtend-gen/org/eclipse/osbp/xtext/strategy/ui/outline/StrategyDSLOutlineTreeProvider.java b/org.eclipse.osbp.xtext.strategy.ui/xtend-gen/org/eclipse/osbp/xtext/strategy/ui/outline/StrategyDSLOutlineTreeProvider.java new file mode 100644 index 0000000..400dc27 --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/xtend-gen/org/eclipse/osbp/xtext/strategy/ui/outline/StrategyDSLOutlineTreeProvider.java @@ -0,0 +1,26 @@ +/** + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + * + * This copyright notice shows up in the generated Java code + */ +package org.eclipse.osbp.xtext.strategy.ui.outline; + +import org.eclipse.xtext.ui.editor.outline.impl.DefaultOutlineTreeProvider; + +/** + * Customization of the default outline structure. + * + * see http://www.eclipse.org/Xtext/documentation.html#outline + */ +@SuppressWarnings("all") +public class StrategyDSLOutlineTreeProvider extends DefaultOutlineTreeProvider { +} diff --git a/org.eclipse.osbp.xtext.strategy.ui/xtend-gen/org/eclipse/osbp/xtext/strategy/ui/quickfix/StrategyDSLQuickfixProvider.java b/org.eclipse.osbp.xtext.strategy.ui/xtend-gen/org/eclipse/osbp/xtext/strategy/ui/quickfix/StrategyDSLQuickfixProvider.java new file mode 100644 index 0000000..edbbf2c --- /dev/null +++ b/org.eclipse.osbp.xtext.strategy.ui/xtend-gen/org/eclipse/osbp/xtext/strategy/ui/quickfix/StrategyDSLQuickfixProvider.java @@ -0,0 +1,26 @@ +/** + * 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: + * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation + * + * + * This copyright notice shows up in the generated Java code + */ +package org.eclipse.osbp.xtext.strategy.ui.quickfix; + +import org.eclipse.xtext.ui.editor.quickfix.DefaultQuickfixProvider; + +/** + * Custom quickfixes. + * + * see http://www.eclipse.org/Xtext/documentation.html#quickfixes + */ +@SuppressWarnings("all") +public class StrategyDSLQuickfixProvider extends DefaultQuickfixProvider { +} |
