Skip to main content
summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to 'org.eclipse.osbp.xtext.table/src-gen/org/eclipse/osbp/xtext/table/parser/antlr/internal/InternalTableDSL.g')
-rw-r--r--org.eclipse.osbp.xtext.table/src-gen/org/eclipse/osbp/xtext/table/parser/antlr/internal/InternalTableDSL.g10014
1 files changed, 10014 insertions, 0 deletions
diff --git a/org.eclipse.osbp.xtext.table/src-gen/org/eclipse/osbp/xtext/table/parser/antlr/internal/InternalTableDSL.g b/org.eclipse.osbp.xtext.table/src-gen/org/eclipse/osbp/xtext/table/parser/antlr/internal/InternalTableDSL.g
new file mode 100644
index 0000000..3a1dd60
--- /dev/null
+++ b/org.eclipse.osbp.xtext.table/src-gen/org/eclipse/osbp/xtext/table/parser/antlr/internal/InternalTableDSL.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 InternalTableDSL;
+
+options {
+ superClass=AbstractInternalAntlrParser;
+
+}
+
+@lexer::header {
+package org.eclipse.osbp.xtext.table.parser.antlr.internal;
+
+// Hack: Use our own Lexer superclass by means of import.
+// Currently there is no other way to specify the superclass for the lexer.
+import org.eclipse.xtext.parser.antlr.Lexer;
+}
+
+@parser::header {
+package org.eclipse.osbp.xtext.table.parser.antlr.internal;
+
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.*;
+import org.eclipse.xtext.parser.impl.*;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.common.util.Enumerator;
+import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
+import org.eclipse.osbp.xtext.table.services.TableDSLGrammarAccess;
+
+}
+
+@parser::members {
+
+ private TableDSLGrammarAccess grammarAccess;
+
+ public InternalTableDSLParser(TokenStream input, TableDSLGrammarAccess grammarAccess) {
+ this(input);
+ this.grammarAccess = grammarAccess;
+ registerRules(grammarAccess.getGrammar());
+ }
+
+ @Override
+ protected String getFirstRuleName() {
+ return "TableModel";
+ }
+
+ @Override
+ protected TableDSLGrammarAccess getGrammarAccess() {
+ return grammarAccess;
+ }
+}
+
+@rulecatch {
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+}
+
+
+
+
+// Entry rule entryRuleTableModel
+entryRuleTableModel returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableModelRule()); }
+ iv_ruleTableModel=ruleTableModel
+ { $current=$iv_ruleTableModel.current; }
+ EOF
+;
+
+// Rule TableModel
+ruleTableModel returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableModelAccess().getPackagesTablePackageParserRuleCall_0());
+ }
+ lv_packages_0_0=ruleTablePackage {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableModelRule());
+ }
+ add(
+ $current,
+ "packages",
+ lv_packages_0_0,
+ "TablePackage");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)*
+;
+
+
+
+
+
+// Entry rule entryRuleTablePackage
+entryRuleTablePackage returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTablePackageRule()); }
+ iv_ruleTablePackage=ruleTablePackage
+ { $current=$iv_ruleTablePackage.current; }
+ EOF
+;
+
+// Rule TablePackage
+ruleTablePackage returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTablePackageAccess().getTablePackageAction_0(),
+ $current);
+ }
+) otherlv_1='package'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTablePackageAccess().getPackageKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTablePackageAccess().getNameQualifiedNameParserRuleCall_2_0());
+ }
+ lv_name_2_0=ruleQualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTablePackageRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_2_0,
+ "QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_3='{'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getTablePackageAccess().getLeftCurlyBracketKeyword_3_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTablePackageAccess().getImportsTableImportParserRuleCall_3_1_0());
+ }
+ lv_imports_4_0=ruleTableImport {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTablePackageRule());
+ }
+ add(
+ $current,
+ "imports",
+ lv_imports_4_0,
+ "TableImport");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)*(
+(
+ {
+ newCompositeNode(grammarAccess.getTablePackageAccess().getTablesTableParserRuleCall_3_2_0());
+ }
+ lv_tables_5_0=ruleTable {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTablePackageRule());
+ }
+ add(
+ $current,
+ "tables",
+ lv_tables_5_0,
+ "Table");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)* otherlv_6='}'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getTablePackageAccess().getRightCurlyBracketKeyword_3_3());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleTable
+entryRuleTable returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableRule()); }
+ iv_ruleTable=ruleTable
+ { $current=$iv_ruleTable.current; }
+ EOF
+;
+
+// Rule Table
+ruleTable returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTableAccess().getTableAction_0(),
+ $current);
+ }
+) otherlv_1='table'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableAccess().getTableKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableAccess().getNameTRANSLATABLEIDParserRuleCall_2_0());
+ }
+ lv_name_2_0=ruleTRANSLATABLEID {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_2_0,
+ "TRANSLATABLEID");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((
+(
+ lv_description_3_0= 'described by'
+ {
+ newLeafNode(lv_description_3_0, grammarAccess.getTableAccess().getDescriptionDescribedByKeyword_3_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableRule());
+ }
+ setWithLastConsumed($current, "description", true, "described by");
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getTableAccess().getDescriptionValueTRANSLATABLESTRINGParserRuleCall_3_1_0());
+ }
+ lv_descriptionValue_4_0=ruleTRANSLATABLESTRING {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableRule());
+ }
+ set(
+ $current,
+ "descriptionValue",
+ lv_descriptionValue_4_0,
+ "TRANSLATABLESTRING");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))? otherlv_5='as'
+ {
+ newLeafNode(otherlv_5, grammarAccess.getTableAccess().getAsKeyword_4());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableAccess().getTabletypeTableOptionParserRuleCall_5_0());
+ }
+ lv_tabletype_6_0=ruleTableOption {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableRule());
+ }
+ set(
+ $current,
+ "tabletype",
+ lv_tabletype_6_0,
+ "TableOption");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableOption
+entryRuleTableOption returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableOptionRule()); }
+ iv_ruleTableOption=ruleTableOption
+ { $current=$iv_ruleTableOption.current; }
+ EOF
+;
+
+// Rule TableOption
+ruleTableOption returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getTableOptionAccess().getTableSelectionParserRuleCall_0());
+ }
+ this_TableSelection_0=ruleTableSelection
+ {
+ $current = $this_TableSelection_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTableOptionAccess().getTableTableParserRuleCall_1());
+ }
+ this_TableTable_1=ruleTableTable
+ {
+ $current = $this_TableTable_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTableOptionAccess().getTableGridParserRuleCall_2());
+ }
+ this_TableGrid_2=ruleTableGrid
+ {
+ $current = $this_TableGrid_2.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleTableSelection
+entryRuleTableSelection returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableSelectionRule()); }
+ iv_ruleTableSelection=ruleTableSelection
+ { $current=$iv_ruleTableSelection.current; }
+ EOF
+;
+
+// Rule TableSelection
+ruleTableSelection returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTableSelectionAccess().getTableSelectionAction_0(),
+ $current);
+ }
+)((
+(
+ lv_multiSelection_1_0= 'multiselection'
+ {
+ newLeafNode(lv_multiSelection_1_0, grammarAccess.getTableSelectionAccess().getMultiSelectionMultiselectionKeyword_1_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableSelectionRule());
+ }
+ setWithLastConsumed($current, "multiSelection", true, "multiselection");
+ }
+
+)
+)
+ | otherlv_2='singleselection'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getTableSelectionAccess().getSingleselectionKeyword_1_1());
+ }
+)(
+
+(
+ {
+ getUnorderedGroupHelper().enter(grammarAccess.getTableSelectionAccess().getUnorderedGroup_2());
+ }
+ (
+ (
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableSelectionAccess().getUnorderedGroup_2(), 0)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableSelectionAccess().getUnorderedGroup_2(), 0);
+ }
+ ({true}?=>(
+(
+ lv_selectalways_4_0= 'selectalways'
+ {
+ newLeafNode(lv_selectalways_4_0, grammarAccess.getTableSelectionAccess().getSelectalwaysSelectalwaysKeyword_2_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableSelectionRule());
+ }
+ setWithLastConsumed($current, "selectalways", true, "selectalways");
+ }
+
+)
+))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableSelectionAccess().getUnorderedGroup_2());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableSelectionAccess().getUnorderedGroup_2(), 1)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableSelectionAccess().getUnorderedGroup_2(), 1);
+ }
+ ({true}?=>( otherlv_5='rowheader'
+ {
+ newLeafNode(otherlv_5, grammarAccess.getTableSelectionAccess().getRowheaderKeyword_2_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableSelectionAccess().getHeaderModeRowHeaderModeEnumRuleCall_2_1_1_0());
+ }
+ lv_headerMode_6_0=ruleRowHeaderMode {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableSelectionRule());
+ }
+ set(
+ $current,
+ "headerMode",
+ lv_headerMode_6_0,
+ "RowHeaderMode");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableSelectionAccess().getUnorderedGroup_2());
+ }
+ )
+ )
+
+ )*
+ )
+)
+ {
+ getUnorderedGroupHelper().leave(grammarAccess.getTableSelectionAccess().getUnorderedGroup_2());
+ }
+
+)(
+
+(
+ {
+ getUnorderedGroupHelper().enter(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3());
+ }
+ (
+ (
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3(), 0)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3(), 0);
+ }
+ ({true}?=>((
+(
+ lv_polling_8_0= 'polling'
+ {
+ newLeafNode(lv_polling_8_0, grammarAccess.getTableSelectionAccess().getPollingPollingKeyword_3_0_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableSelectionRule());
+ }
+ setWithLastConsumed($current, "polling", true, "polling");
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getTableSelectionAccess().getPollingTimeNumberParserRuleCall_3_0_1_0());
+ }
+ lv_pollingTime_9_0=ruleNumber {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableSelectionRule());
+ }
+ set(
+ $current,
+ "pollingTime",
+ lv_pollingTime_9_0,
+ "Number");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3(), 1)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3(), 1);
+ }
+ ({true}?=>(
+(
+ lv_filtering_10_0= 'filtering'
+ {
+ newLeafNode(lv_filtering_10_0, grammarAccess.getTableSelectionAccess().getFilteringFilteringKeyword_3_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableSelectionRule());
+ }
+ setWithLastConsumed($current, "filtering", true, "filtering");
+ }
+
+)
+))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3(), 2)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3(), 2);
+ }
+ ({true}?=>(
+(
+ lv_embedded_11_0= 'embedded'
+ {
+ newLeafNode(lv_embedded_11_0, grammarAccess.getTableSelectionAccess().getEmbeddedEmbeddedKeyword_3_2_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableSelectionRule());
+ }
+ setWithLastConsumed($current, "embedded", true, "embedded");
+ }
+
+)
+))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3(), 3)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3(), 3);
+ }
+ ({true}?=>( otherlv_12='toolbar'
+ {
+ newLeafNode(otherlv_12, grammarAccess.getTableSelectionAccess().getToolbarKeyword_3_3_0());
+ }
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableSelectionRule());
+ }
+ }
+ otherlv_13=RULE_ID
+ {
+ newLeafNode(otherlv_13, grammarAccess.getTableSelectionAccess().getToolbarActionToolbarCrossReference_3_3_1_0());
+ }
+
+)
+)))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3());
+ }
+ )
+ )
+
+ )*
+ )
+)
+ {
+ getUnorderedGroupHelper().leave(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3());
+ }
+
+)( otherlv_14='using'
+ {
+ newLeafNode(otherlv_14, grammarAccess.getTableSelectionAccess().getUsingKeyword_4_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableSelectionAccess().getSourceTableDatamartParserRuleCall_4_1_0());
+ }
+ lv_source_15_0=ruleTableDatamart {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableSelectionRule());
+ }
+ set(
+ $current,
+ "source",
+ lv_source_15_0,
+ "TableDatamart");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleTableTable
+entryRuleTableTable returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableTableRule()); }
+ iv_ruleTableTable=ruleTableTable
+ { $current=$iv_ruleTableTable.current; }
+ EOF
+;
+
+// Rule TableTable
+ruleTableTable returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTableTableAccess().getTableTableAction_0(),
+ $current);
+ }
+) otherlv_1='table'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableTableAccess().getTableKeyword_1());
+ }
+(
+
+(
+ {
+ getUnorderedGroupHelper().enter(grammarAccess.getTableTableAccess().getUnorderedGroup_2());
+ }
+ (
+ (
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableTableAccess().getUnorderedGroup_2(), 0)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableTableAccess().getUnorderedGroup_2(), 0);
+ }
+ ({true}?=>(
+(
+ lv_selectalways_3_0= 'selectalways'
+ {
+ newLeafNode(lv_selectalways_3_0, grammarAccess.getTableTableAccess().getSelectalwaysSelectalwaysKeyword_2_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableTableRule());
+ }
+ setWithLastConsumed($current, "selectalways", true, "selectalways");
+ }
+
+)
+))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableTableAccess().getUnorderedGroup_2());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableTableAccess().getUnorderedGroup_2(), 1)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableTableAccess().getUnorderedGroup_2(), 1);
+ }
+ ({true}?=>( otherlv_4='rowheader'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getTableTableAccess().getRowheaderKeyword_2_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableTableAccess().getHeaderModeRowHeaderModeEnumRuleCall_2_1_1_0());
+ }
+ lv_headerMode_5_0=ruleRowHeaderMode {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableTableRule());
+ }
+ set(
+ $current,
+ "headerMode",
+ lv_headerMode_5_0,
+ "RowHeaderMode");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableTableAccess().getUnorderedGroup_2());
+ }
+ )
+ )
+
+ )*
+ )
+)
+ {
+ getUnorderedGroupHelper().leave(grammarAccess.getTableTableAccess().getUnorderedGroup_2());
+ }
+
+)(
+
+(
+ {
+ getUnorderedGroupHelper().enter(grammarAccess.getTableTableAccess().getUnorderedGroup_3());
+ }
+ (
+ (
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableTableAccess().getUnorderedGroup_3(), 0)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableTableAccess().getUnorderedGroup_3(), 0);
+ }
+ ({true}?=>((
+(
+ lv_polling_7_0= 'polling'
+ {
+ newLeafNode(lv_polling_7_0, grammarAccess.getTableTableAccess().getPollingPollingKeyword_3_0_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableTableRule());
+ }
+ setWithLastConsumed($current, "polling", true, "polling");
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getTableTableAccess().getPollingTimeNumberParserRuleCall_3_0_1_0());
+ }
+ lv_pollingTime_8_0=ruleNumber {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableTableRule());
+ }
+ set(
+ $current,
+ "pollingTime",
+ lv_pollingTime_8_0,
+ "Number");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableTableAccess().getUnorderedGroup_3());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableTableAccess().getUnorderedGroup_3(), 1)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableTableAccess().getUnorderedGroup_3(), 1);
+ }
+ ({true}?=>(
+(
+ lv_filtering_9_0= 'filtering'
+ {
+ newLeafNode(lv_filtering_9_0, grammarAccess.getTableTableAccess().getFilteringFilteringKeyword_3_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableTableRule());
+ }
+ setWithLastConsumed($current, "filtering", true, "filtering");
+ }
+
+)
+))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableTableAccess().getUnorderedGroup_3());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableTableAccess().getUnorderedGroup_3(), 2)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableTableAccess().getUnorderedGroup_3(), 2);
+ }
+ ({true}?=>(
+(
+ lv_embedded_10_0= 'embedded'
+ {
+ newLeafNode(lv_embedded_10_0, grammarAccess.getTableTableAccess().getEmbeddedEmbeddedKeyword_3_2_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableTableRule());
+ }
+ setWithLastConsumed($current, "embedded", true, "embedded");
+ }
+
+)
+))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableTableAccess().getUnorderedGroup_3());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableTableAccess().getUnorderedGroup_3(), 3)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableTableAccess().getUnorderedGroup_3(), 3);
+ }
+ ({true}?=>( otherlv_11='toolbar'
+ {
+ newLeafNode(otherlv_11, grammarAccess.getTableTableAccess().getToolbarKeyword_3_3_0());
+ }
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableTableRule());
+ }
+ }
+ otherlv_12=RULE_ID
+ {
+ newLeafNode(otherlv_12, grammarAccess.getTableTableAccess().getToolbarActionToolbarCrossReference_3_3_1_0());
+ }
+
+)
+)))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableTableAccess().getUnorderedGroup_3());
+ }
+ )
+ )
+
+ )*
+ )
+)
+ {
+ getUnorderedGroupHelper().leave(grammarAccess.getTableTableAccess().getUnorderedGroup_3());
+ }
+
+)( otherlv_13='using'
+ {
+ newLeafNode(otherlv_13, grammarAccess.getTableTableAccess().getUsingKeyword_4_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableTableAccess().getSourceTableDatamartParserRuleCall_4_1_0());
+ }
+ lv_source_14_0=ruleTableDatamart {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableTableRule());
+ }
+ set(
+ $current,
+ "source",
+ lv_source_14_0,
+ "TableDatamart");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleTablePreorder
+entryRuleTablePreorder returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTablePreorderRule()); }
+ iv_ruleTablePreorder=ruleTablePreorder
+ { $current=$iv_ruleTablePreorder.current; }
+ EOF
+;
+
+// Rule TablePreorder
+ruleTablePreorder returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTablePreorderAccess().getTablePreorderAction_0(),
+ $current);
+ }
+) otherlv_1='preorder'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTablePreorderAccess().getPreorderKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTablePreorderAccess().getColumnTableValueElementParserRuleCall_2_0());
+ }
+ lv_column_2_0=ruleTableValueElement {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTablePreorderRule());
+ }
+ set(
+ $current,
+ "column",
+ lv_column_2_0,
+ "TableValueElement");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ lv_ascending_3_0= 'ascending'
+ {
+ newLeafNode(lv_ascending_3_0, grammarAccess.getTablePreorderAccess().getAscendingAscendingKeyword_3_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTablePreorderRule());
+ }
+ setWithLastConsumed($current, "ascending", true, "ascending");
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleTableValue
+entryRuleTableValue returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableValueRule()); }
+ iv_ruleTableValue=ruleTableValue
+ { $current=$iv_ruleTableValue.current; }
+ EOF
+;
+
+// Rule TableValue
+ruleTableValue returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTableValueAccess().getTableValueAction_0(),
+ $current);
+ }
+) otherlv_1='value'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableValueAccess().getValueKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableValueAccess().getColumnTableValueElementParserRuleCall_2_0());
+ }
+ lv_column_2_0=ruleTableValueElement {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableValueRule());
+ }
+ set(
+ $current,
+ "column",
+ lv_column_2_0,
+ "TableValueElement");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+
+(
+ {
+ getUnorderedGroupHelper().enter(grammarAccess.getTableValueAccess().getUnorderedGroup_3());
+ }
+ (
+ (
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableValueAccess().getUnorderedGroup_3(), 0)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableValueAccess().getUnorderedGroup_3(), 0);
+ }
+ ({true}?=>(
+(
+ lv_collapsed_4_0= 'collapse'
+ {
+ newLeafNode(lv_collapsed_4_0, grammarAccess.getTableValueAccess().getCollapsedCollapseKeyword_3_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableValueRule());
+ }
+ setWithLastConsumed($current, "collapsed", true, "collapse");
+ }
+
+)
+))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableValueAccess().getUnorderedGroup_3());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableValueAccess().getUnorderedGroup_3(), 1)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableValueAccess().getUnorderedGroup_3(), 1);
+ }
+ ({true}?=>( otherlv_5='icon'
+ {
+ newLeafNode(otherlv_5, grammarAccess.getTableValueAccess().getIconKeyword_3_1_0());
+ }
+(
+(
+ lv_iconName_6_0=RULE_STRING
+ {
+ newLeafNode(lv_iconName_6_0, grammarAccess.getTableValueAccess().getIconNameSTRINGTerminalRuleCall_3_1_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableValueRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "iconName",
+ lv_iconName_6_0,
+ "STRING");
+ }
+
+)
+)))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableValueAccess().getUnorderedGroup_3());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableValueAccess().getUnorderedGroup_3(), 2)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableValueAccess().getUnorderedGroup_3(), 2);
+ }
+ ({true}?=>(
+(
+ {
+ newCompositeNode(grammarAccess.getTableValueAccess().getFormatterTableFormatterParserRuleCall_3_2_0());
+ }
+ lv_formatter_7_0=ruleTableFormatter {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableValueRule());
+ }
+ set(
+ $current,
+ "formatter",
+ lv_formatter_7_0,
+ "TableFormatter");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableValueAccess().getUnorderedGroup_3());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableValueAccess().getUnorderedGroup_3(), 3)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableValueAccess().getUnorderedGroup_3(), 3);
+ }
+ ({true}?=>((
+(
+ lv_hasImage_8_0= 'image'
+ {
+ newLeafNode(lv_hasImage_8_0, grammarAccess.getTableValueAccess().getHasImageImageKeyword_3_3_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableValueRule());
+ }
+ setWithLastConsumed($current, "hasImage", true, "image");
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getTableValueAccess().getImageTableImageParserRuleCall_3_3_1_0());
+ }
+ lv_image_9_0=ruleTableImage {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableValueRule());
+ }
+ set(
+ $current,
+ "image",
+ lv_image_9_0,
+ "TableImage");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableValueAccess().getUnorderedGroup_3());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableValueAccess().getUnorderedGroup_3(), 4)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableValueAccess().getUnorderedGroup_3(), 4);
+ }
+ ({true}?=>(
+(
+ {
+ newCompositeNode(grammarAccess.getTableValueAccess().getTooltipPatternTableTooltipPatternParserRuleCall_3_4_0());
+ }
+ lv_tooltipPattern_10_0=ruleTableTooltipPattern {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableValueRule());
+ }
+ set(
+ $current,
+ "tooltipPattern",
+ lv_tooltipPattern_10_0,
+ "TableTooltipPattern");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableValueAccess().getUnorderedGroup_3());
+ }
+ )
+ )
+
+ )*
+ )
+)
+ {
+ getUnorderedGroupHelper().leave(grammarAccess.getTableValueAccess().getUnorderedGroup_3());
+ }
+
+)(
+
+(
+ {
+ getUnorderedGroupHelper().enter(grammarAccess.getTableValueAccess().getUnorderedGroup_4());
+ }
+ (
+ (
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableValueAccess().getUnorderedGroup_4(), 0)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableValueAccess().getUnorderedGroup_4(), 0);
+ }
+ ({true}?=>( otherlv_12='intervals'
+ {
+ newLeafNode(otherlv_12, grammarAccess.getTableValueAccess().getIntervalsKeyword_4_0_0());
+ }
+(
+(
+ lv_hideLabelInterval_13_0= 'hidelabel'
+ {
+ newLeafNode(lv_hideLabelInterval_13_0, grammarAccess.getTableValueAccess().getHideLabelIntervalHidelabelKeyword_4_0_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableValueRule());
+ }
+ setWithLastConsumed($current, "hideLabelInterval", true, "hidelabel");
+ }
+
+)
+)? otherlv_14='{'
+ {
+ newLeafNode(otherlv_14, grammarAccess.getTableValueAccess().getLeftCurlyBracketKeyword_4_0_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableValueAccess().getIntervalsTableIntervalParserRuleCall_4_0_3_0());
+ }
+ lv_intervals_15_0=ruleTableInterval {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableValueRule());
+ }
+ add(
+ $current,
+ "intervals",
+ lv_intervals_15_0,
+ "TableInterval");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)* otherlv_16='}'
+ {
+ newLeafNode(otherlv_16, grammarAccess.getTableValueAccess().getRightCurlyBracketKeyword_4_0_4());
+ }
+))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableValueAccess().getUnorderedGroup_4());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableValueAccess().getUnorderedGroup_4(), 1)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableValueAccess().getUnorderedGroup_4(), 1);
+ }
+ ({true}?=>( otherlv_17='lookups'
+ {
+ newLeafNode(otherlv_17, grammarAccess.getTableValueAccess().getLookupsKeyword_4_1_0());
+ }
+(
+(
+ lv_hideLabelLookup_18_0= 'hidelabel'
+ {
+ newLeafNode(lv_hideLabelLookup_18_0, grammarAccess.getTableValueAccess().getHideLabelLookupHidelabelKeyword_4_1_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableValueRule());
+ }
+ setWithLastConsumed($current, "hideLabelLookup", true, "hidelabel");
+ }
+
+)
+)? otherlv_19='{'
+ {
+ newLeafNode(otherlv_19, grammarAccess.getTableValueAccess().getLeftCurlyBracketKeyword_4_1_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableValueAccess().getLookupsTableLookupParserRuleCall_4_1_3_0());
+ }
+ lv_lookups_20_0=ruleTableLookup {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableValueRule());
+ }
+ add(
+ $current,
+ "lookups",
+ lv_lookups_20_0,
+ "TableLookup");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)* otherlv_21='}'
+ {
+ newLeafNode(otherlv_21, grammarAccess.getTableValueAccess().getRightCurlyBracketKeyword_4_1_4());
+ }
+))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableValueAccess().getUnorderedGroup_4());
+ }
+ )
+ )
+
+ )*
+ )
+)
+ {
+ getUnorderedGroupHelper().leave(grammarAccess.getTableValueAccess().getUnorderedGroup_4());
+ }
+
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableFormatter
+entryRuleTableFormatter returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableFormatterRule()); }
+ iv_ruleTableFormatter=ruleTableFormatter
+ { $current=$iv_ruleTableFormatter.current; }
+ EOF
+;
+
+// Rule TableFormatter
+ruleTableFormatter returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTableFormatterAccess().getTableFormatterAction_0(),
+ $current);
+ }
+) otherlv_1='formatter'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableFormatterAccess().getFormatterKeyword_1());
+ }
+(
+(
+ lv_format_2_0=RULE_STRING
+ {
+ newLeafNode(lv_format_2_0, grammarAccess.getTableFormatterAccess().getFormatSTRINGTerminalRuleCall_2_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableFormatterRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "format",
+ lv_format_2_0,
+ "STRING");
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableImage
+entryRuleTableImage returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableImageRule()); }
+ iv_ruleTableImage=ruleTableImage
+ { $current=$iv_ruleTableImage.current; }
+ EOF
+;
+
+// Rule TableImage
+ruleTableImage returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTableImageAccess().getTableImageAction_0(),
+ $current);
+ }
+) otherlv_1='path'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableImageAccess().getPathKeyword_1());
+ }
+(
+(
+ lv_imagePathPattern_2_0=RULE_STRING
+ {
+ newLeafNode(lv_imagePathPattern_2_0, grammarAccess.getTableImageAccess().getImagePathPatternSTRINGTerminalRuleCall_2_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableImageRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "imagePathPattern",
+ lv_imagePathPattern_2_0,
+ "STRING");
+ }
+
+)
+)(
+
+(
+ {
+ getUnorderedGroupHelper().enter(grammarAccess.getTableImageAccess().getUnorderedGroup_3());
+ }
+ (
+ (
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableImageAccess().getUnorderedGroup_3(), 0)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableImageAccess().getUnorderedGroup_3(), 0);
+ }
+ ({true}?=>(
+(
+ lv_hasParameter_4_0= 'dynamic'
+ {
+ newLeafNode(lv_hasParameter_4_0, grammarAccess.getTableImageAccess().getHasParameterDynamicKeyword_3_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableImageRule());
+ }
+ setWithLastConsumed($current, "hasParameter", true, "dynamic");
+ }
+
+)
+))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableImageAccess().getUnorderedGroup_3());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableImageAccess().getUnorderedGroup_3(), 1)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableImageAccess().getUnorderedGroup_3(), 1);
+ }
+ ({true}?=>(
+(
+ lv_hideImageLabel_5_0= 'hidelabel'
+ {
+ newLeafNode(lv_hideImageLabel_5_0, grammarAccess.getTableImageAccess().getHideImageLabelHidelabelKeyword_3_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableImageRule());
+ }
+ setWithLastConsumed($current, "hideImageLabel", true, "hidelabel");
+ }
+
+)
+))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableImageAccess().getUnorderedGroup_3());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableImageAccess().getUnorderedGroup_3(), 2)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableImageAccess().getUnorderedGroup_3(), 2);
+ }
+ ({true}?=>((
+(
+ lv_resize_6_0= 'resize'
+ {
+ newLeafNode(lv_resize_6_0, grammarAccess.getTableImageAccess().getResizeResizeKeyword_3_2_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableImageRule());
+ }
+ setWithLastConsumed($current, "resize", true, "resize");
+ }
+
+)
+)(
+(
+ lv_resizeString_7_0=RULE_STRING
+ {
+ newLeafNode(lv_resizeString_7_0, grammarAccess.getTableImageAccess().getResizeStringSTRINGTerminalRuleCall_3_2_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableImageRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "resizeString",
+ lv_resizeString_7_0,
+ "STRING");
+ }
+
+)
+)))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableImageAccess().getUnorderedGroup_3());
+ }
+ )
+ )
+
+ )*
+ )
+)
+ {
+ getUnorderedGroupHelper().leave(grammarAccess.getTableImageAccess().getUnorderedGroup_3());
+ }
+
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableTooltipPattern
+entryRuleTableTooltipPattern returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableTooltipPatternRule()); }
+ iv_ruleTableTooltipPattern=ruleTableTooltipPattern
+ { $current=$iv_ruleTableTooltipPattern.current; }
+ EOF
+;
+
+// Rule TableTooltipPattern
+ruleTableTooltipPattern returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTableTooltipPatternAccess().getTableTooltipPatternAction_0(),
+ $current);
+ }
+) otherlv_1='tooltipPattern'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableTooltipPatternAccess().getTooltipPatternKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableTooltipPatternAccess().getTooltipPatternTRANSLATABLESTRINGParserRuleCall_2_0());
+ }
+ lv_tooltipPattern_2_0=ruleTRANSLATABLESTRING {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableTooltipPatternRule());
+ }
+ set(
+ $current,
+ "tooltipPattern",
+ lv_tooltipPattern_2_0,
+ "TRANSLATABLESTRING");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableValueElement
+entryRuleTableValueElement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableValueElementRule()); }
+ iv_ruleTableValueElement=ruleTableValueElement
+ { $current=$iv_ruleTableValueElement.current; }
+ EOF
+;
+
+// Rule TableValueElement
+ruleTableValueElement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getTableValueElementAccess().getTableMeasureParserRuleCall_0());
+ }
+ this_TableMeasure_0=ruleTableMeasure
+ {
+ $current = $this_TableMeasure_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTableValueElementAccess().getTableDerivedParserRuleCall_1());
+ }
+ this_TableDerived_1=ruleTableDerived
+ {
+ $current = $this_TableDerived_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTableValueElementAccess().getTableHierarchyParserRuleCall_2());
+ }
+ this_TableHierarchy_2=ruleTableHierarchy
+ {
+ $current = $this_TableHierarchy_2.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTableValueElementAccess().getTablePropertyParserRuleCall_3());
+ }
+ this_TableProperty_3=ruleTableProperty
+ {
+ $current = $this_TableProperty_3.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTableValueElementAccess().getTableAggregationParserRuleCall_4());
+ }
+ this_TableAggregation_4=ruleTableAggregation
+ {
+ $current = $this_TableAggregation_4.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTableValueElementAccess().getTableOrdinalParserRuleCall_5());
+ }
+ this_TableOrdinal_5=ruleTableOrdinal
+ {
+ $current = $this_TableOrdinal_5.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTableValueElementAccess().getTableColumnParserRuleCall_6());
+ }
+ this_TableColumn_6=ruleTableColumn
+ {
+ $current = $this_TableColumn_6.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTableValueElementAccess().getTableTaskParserRuleCall_7());
+ }
+ this_TableTask_7=ruleTableTask
+ {
+ $current = $this_TableTask_7.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTableValueElementAccess().getTableAllColumnsParserRuleCall_8());
+ }
+ this_TableAllColumns_8=ruleTableAllColumns
+ {
+ $current = $this_TableAllColumns_8.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleTableTask
+entryRuleTableTask returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableTaskRule()); }
+ iv_ruleTableTask=ruleTableTask
+ { $current=$iv_ruleTableTask.current; }
+ EOF
+;
+
+// Rule TableTask
+ruleTableTask returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTableTaskAccess().getTableTaskAction_0(),
+ $current);
+ }
+) otherlv_1='taskId'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableTaskAccess().getTaskIdKeyword_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleTableAllColumns
+entryRuleTableAllColumns returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableAllColumnsRule()); }
+ iv_ruleTableAllColumns=ruleTableAllColumns
+ { $current=$iv_ruleTableAllColumns.current; }
+ EOF
+;
+
+// Rule TableAllColumns
+ruleTableAllColumns returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTableAllColumnsAccess().getTableAllColumnsAction_0(),
+ $current);
+ }
+) otherlv_1='allColumns'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableAllColumnsAccess().getAllColumnsKeyword_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleTableOrdinal
+entryRuleTableOrdinal returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableOrdinalRule()); }
+ iv_ruleTableOrdinal=ruleTableOrdinal
+ { $current=$iv_ruleTableOrdinal.current; }
+ EOF
+;
+
+// Rule TableOrdinal
+ruleTableOrdinal returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='ordinal'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTableOrdinalAccess().getOrdinalKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableOrdinalAccess().getValueRefNumberParserRuleCall_1_0());
+ }
+ lv_valueRef_1_0=ruleNumber {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableOrdinalRule());
+ }
+ set(
+ $current,
+ "valueRef",
+ lv_valueRef_1_0,
+ "Number");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableColumn
+entryRuleTableColumn returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableColumnRule()); }
+ iv_ruleTableColumn=ruleTableColumn
+ { $current=$iv_ruleTableColumn.current; }
+ EOF
+;
+
+// Rule TableColumn
+ruleTableColumn returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='column'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTableColumnAccess().getColumnKeyword_0());
+ }
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableColumnRule());
+ }
+ }
+ otherlv_1=RULE_ID
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableColumnAccess().getValueRefDatamartColumnCrossReference_1_0());
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableMeasure
+entryRuleTableMeasure returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableMeasureRule()); }
+ iv_ruleTableMeasure=ruleTableMeasure
+ { $current=$iv_ruleTableMeasure.current; }
+ EOF
+;
+
+// Rule TableMeasure
+ruleTableMeasure returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='measure'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTableMeasureAccess().getMeasureKeyword_0());
+ }
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableMeasureRule());
+ }
+ }
+ otherlv_1=RULE_ID
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableMeasureAccess().getValueRefDatamartMeasureCrossReference_1_0());
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableDerived
+entryRuleTableDerived returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableDerivedRule()); }
+ iv_ruleTableDerived=ruleTableDerived
+ { $current=$iv_ruleTableDerived.current; }
+ EOF
+;
+
+// Rule TableDerived
+ruleTableDerived returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='derived'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTableDerivedAccess().getDerivedKeyword_0());
+ }
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableDerivedRule());
+ }
+ }
+ otherlv_1=RULE_ID
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableDerivedAccess().getValueRefDatamartDerivedMeasureCrossReference_1_0());
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableHierarchy
+entryRuleTableHierarchy returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableHierarchyRule()); }
+ iv_ruleTableHierarchy=ruleTableHierarchy
+ { $current=$iv_ruleTableHierarchy.current; }
+ EOF
+;
+
+// Rule TableHierarchy
+ruleTableHierarchy returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='level'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTableHierarchyAccess().getLevelKeyword_0());
+ }
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableHierarchyRule());
+ }
+ }
+ otherlv_1=RULE_ID
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableHierarchyAccess().getValueRefCubeLevelCrossReference_1_0());
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableProperty
+entryRuleTableProperty returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTablePropertyRule()); }
+ iv_ruleTableProperty=ruleTableProperty
+ { $current=$iv_ruleTableProperty.current; }
+ EOF
+;
+
+// Rule TableProperty
+ruleTableProperty returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTablePropertyAccess().getTablePropertyAction_0(),
+ $current);
+ }
+) otherlv_1='property'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTablePropertyAccess().getPropertyKeyword_1());
+ }
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTablePropertyRule());
+ }
+ }
+ otherlv_2=RULE_ID
+ {
+ newLeafNode(otherlv_2, grammarAccess.getTablePropertyAccess().getValueRefDatamartPropertyCrossReference_2_0());
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableAggregation
+entryRuleTableAggregation returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableAggregationRule()); }
+ iv_ruleTableAggregation=ruleTableAggregation
+ { $current=$iv_ruleTableAggregation.current; }
+ EOF
+;
+
+// Rule TableAggregation
+ruleTableAggregation returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='aggregation'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTableAggregationAccess().getAggregationKeyword_0());
+ }
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableAggregationRule());
+ }
+ }
+ otherlv_1=RULE_ID
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableAggregationAccess().getValueRefDatamartSetAggregationFunctionCrossReference_1_0());
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableInterval
+entryRuleTableInterval returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableIntervalRule()); }
+ iv_ruleTableInterval=ruleTableInterval
+ { $current=$iv_ruleTableInterval.current; }
+ EOF
+;
+
+// Rule TableInterval
+ruleTableInterval returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getTableIntervalAccess().getTableNumberIntervalParserRuleCall_0());
+ }
+ this_TableNumberInterval_0=ruleTableNumberInterval
+ {
+ $current = $this_TableNumberInterval_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTableIntervalAccess().getTableDateDayIntervalParserRuleCall_1());
+ }
+ this_TableDateDayInterval_1=ruleTableDateDayInterval
+ {
+ $current = $this_TableDateDayInterval_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleTableNumberInterval
+entryRuleTableNumberInterval returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableNumberIntervalRule()); }
+ iv_ruleTableNumberInterval=ruleTableNumberInterval
+ { $current=$iv_ruleTableNumberInterval.current; }
+ EOF
+;
+
+// Rule TableNumberInterval
+ruleTableNumberInterval returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTableNumberIntervalAccess().getTableNumberIntervalAction_0(),
+ $current);
+ }
+) otherlv_1='up to'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableNumberIntervalAccess().getUpToKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableNumberIntervalAccess().getNumberIntervalValueSignedNumberParserRuleCall_2_0());
+ }
+ lv_numberIntervalValue_2_0=ruleSignedNumber {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableNumberIntervalRule());
+ }
+ set(
+ $current,
+ "numberIntervalValue",
+ lv_numberIntervalValue_2_0,
+ "SignedNumber");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getTableNumberIntervalAccess().getNumberRangeTableRangeElementParserRuleCall_3_0());
+ }
+ lv_numberRange_3_0=ruleTableRangeElement {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableNumberIntervalRule());
+ }
+ set(
+ $current,
+ "numberRange",
+ lv_numberRange_3_0,
+ "TableRangeElement");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableDateDayInterval
+entryRuleTableDateDayInterval returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableDateDayIntervalRule()); }
+ iv_ruleTableDateDayInterval=ruleTableDateDayInterval
+ { $current=$iv_ruleTableDateDayInterval.current; }
+ EOF
+;
+
+// Rule TableDateDayInterval
+ruleTableDateDayInterval returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTableDateDayIntervalAccess().getTableDateDayIntervalAction_0(),
+ $current);
+ }
+) otherlv_1='days in past'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableDateDayIntervalAccess().getDaysInPastKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableDateDayIntervalAccess().getDateIntervalValueSignedNumberParserRuleCall_2_0());
+ }
+ lv_dateIntervalValue_2_0=ruleSignedNumber {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableDateDayIntervalRule());
+ }
+ set(
+ $current,
+ "dateIntervalValue",
+ lv_dateIntervalValue_2_0,
+ "SignedNumber");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getTableDateDayIntervalAccess().getDateRangeTableRangeElementParserRuleCall_3_0());
+ }
+ lv_dateRange_3_0=ruleTableRangeElement {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableDateDayIntervalRule());
+ }
+ set(
+ $current,
+ "dateRange",
+ lv_dateRange_3_0,
+ "TableRangeElement");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableLookup
+entryRuleTableLookup returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableLookupRule()); }
+ iv_ruleTableLookup=ruleTableLookup
+ { $current=$iv_ruleTableLookup.current; }
+ EOF
+;
+
+// Rule TableLookup
+ruleTableLookup returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getTableLookupAccess().getTableNumberLookupParserRuleCall_0());
+ }
+ this_TableNumberLookup_0=ruleTableNumberLookup
+ {
+ $current = $this_TableNumberLookup_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTableLookupAccess().getTableStringLookupParserRuleCall_1());
+ }
+ this_TableStringLookup_1=ruleTableStringLookup
+ {
+ $current = $this_TableStringLookup_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTableLookupAccess().getTableDateDayLookupParserRuleCall_2());
+ }
+ this_TableDateDayLookup_2=ruleTableDateDayLookup
+ {
+ $current = $this_TableDateDayLookup_2.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleTableNumberLookup
+entryRuleTableNumberLookup returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableNumberLookupRule()); }
+ iv_ruleTableNumberLookup=ruleTableNumberLookup
+ { $current=$iv_ruleTableNumberLookup.current; }
+ EOF
+;
+
+// Rule TableNumberLookup
+ruleTableNumberLookup returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTableNumberLookupAccess().getTableNumberLookupAction_0(),
+ $current);
+ }
+) otherlv_1='number'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableNumberLookupAccess().getNumberKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableNumberLookupAccess().getLookupValueSignedNumberParserRuleCall_2_0());
+ }
+ lv_lookupValue_2_0=ruleSignedNumber {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableNumberLookupRule());
+ }
+ set(
+ $current,
+ "lookupValue",
+ lv_lookupValue_2_0,
+ "SignedNumber");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getTableNumberLookupAccess().getDiscreteTableRangeElementParserRuleCall_3_0());
+ }
+ lv_discrete_3_0=ruleTableRangeElement {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableNumberLookupRule());
+ }
+ set(
+ $current,
+ "discrete",
+ lv_discrete_3_0,
+ "TableRangeElement");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableStringLookup
+entryRuleTableStringLookup returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableStringLookupRule()); }
+ iv_ruleTableStringLookup=ruleTableStringLookup
+ { $current=$iv_ruleTableStringLookup.current; }
+ EOF
+;
+
+// Rule TableStringLookup
+ruleTableStringLookup returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTableStringLookupAccess().getTableStringLookupAction_0(),
+ $current);
+ }
+) otherlv_1='string'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableStringLookupAccess().getStringKeyword_1());
+ }
+(
+(
+ lv_lookupValue_2_0=RULE_STRING
+ {
+ newLeafNode(lv_lookupValue_2_0, grammarAccess.getTableStringLookupAccess().getLookupValueSTRINGTerminalRuleCall_2_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableStringLookupRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "lookupValue",
+ lv_lookupValue_2_0,
+ "STRING");
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getTableStringLookupAccess().getDiscreteTableRangeElementParserRuleCall_3_0());
+ }
+ lv_discrete_3_0=ruleTableRangeElement {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableStringLookupRule());
+ }
+ set(
+ $current,
+ "discrete",
+ lv_discrete_3_0,
+ "TableRangeElement");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableDateDayLookup
+entryRuleTableDateDayLookup returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableDateDayLookupRule()); }
+ iv_ruleTableDateDayLookup=ruleTableDateDayLookup
+ { $current=$iv_ruleTableDateDayLookup.current; }
+ EOF
+;
+
+// Rule TableDateDayLookup
+ruleTableDateDayLookup returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTableDateDayLookupAccess().getTableDateDayLookupAction_0(),
+ $current);
+ }
+) otherlv_1='days in past'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableDateDayLookupAccess().getDaysInPastKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableDateDayLookupAccess().getLookupValueSignedNumberParserRuleCall_2_0());
+ }
+ lv_lookupValue_2_0=ruleSignedNumber {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableDateDayLookupRule());
+ }
+ set(
+ $current,
+ "lookupValue",
+ lv_lookupValue_2_0,
+ "SignedNumber");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getTableDateDayLookupAccess().getDiscreteTableRangeElementParserRuleCall_3_0());
+ }
+ lv_discrete_3_0=ruleTableRangeElement {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableDateDayLookupRule());
+ }
+ set(
+ $current,
+ "discrete",
+ lv_discrete_3_0,
+ "TableRangeElement");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableDatamart
+entryRuleTableDatamart returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableDatamartRule()); }
+ iv_ruleTableDatamart=ruleTableDatamart
+ { $current=$iv_ruleTableDatamart.current; }
+ EOF
+;
+
+// Rule TableDatamart
+ruleTableDatamart returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='datamart'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTableDatamartAccess().getDatamartKeyword_0());
+ }
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableDatamartRule());
+ }
+ }
+ otherlv_1=RULE_ID
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableDatamartAccess().getDatamartRefDatamartDefinitionCrossReference_1_0());
+ }
+
+)
+)( otherlv_2='{'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getTableDatamartAccess().getLeftCurlyBracketKeyword_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableDatamartAccess().getElementsTableElementParserRuleCall_2_1_0());
+ }
+ lv_elements_3_0=ruleTableElement {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableDatamartRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_3_0,
+ "TableElement");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)* otherlv_4='}'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getTableDatamartAccess().getRightCurlyBracketKeyword_2_2());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleTableElement
+entryRuleTableElement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableElementRule()); }
+ iv_ruleTableElement=ruleTableElement
+ { $current=$iv_ruleTableElement.current; }
+ EOF
+;
+
+// Rule TableElement
+ruleTableElement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+
+ {
+ newCompositeNode(grammarAccess.getTableElementAccess().getTableAxisParserRuleCall());
+ }
+ this_TableAxis_0=ruleTableAxis
+ {
+ $current = $this_TableAxis_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+;
+
+
+
+
+
+// Entry rule entryRuleTableEvent
+entryRuleTableEvent returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableEventRule()); }
+ iv_ruleTableEvent=ruleTableEvent
+ { $current=$iv_ruleTableEvent.current; }
+ EOF
+;
+
+// Rule TableEvent
+ruleTableEvent returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='broker'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTableEventAccess().getBrokerKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableEventAccess().getSourceTableValueElementParserRuleCall_1_0());
+ }
+ lv_source_1_0=ruleTableValueElement {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableEventRule());
+ }
+ set(
+ $current,
+ "source",
+ lv_source_1_0,
+ "TableValueElement");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_2='to'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getTableEventAccess().getToKeyword_2());
+ }
+ otherlv_3='{'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getTableEventAccess().getLeftCurlyBracketKeyword_3());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableEventAccess().getBrokerDatamartsTableBrokerDatamartParserRuleCall_4_0());
+ }
+ lv_brokerDatamarts_4_0=ruleTableBrokerDatamart {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableEventRule());
+ }
+ add(
+ $current,
+ "brokerDatamarts",
+ lv_brokerDatamarts_4_0,
+ "TableBrokerDatamart");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)* otherlv_5='}'
+ {
+ newLeafNode(otherlv_5, grammarAccess.getTableEventAccess().getRightCurlyBracketKeyword_5());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleTableBrokerDatamart
+entryRuleTableBrokerDatamart returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableBrokerDatamartRule()); }
+ iv_ruleTableBrokerDatamart=ruleTableBrokerDatamart
+ { $current=$iv_ruleTableBrokerDatamart.current; }
+ EOF
+;
+
+// Rule TableBrokerDatamart
+ruleTableBrokerDatamart returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='datamart'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTableBrokerDatamartAccess().getDatamartKeyword_0());
+ }
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableBrokerDatamartRule());
+ }
+ }
+ otherlv_1=RULE_ID
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableBrokerDatamartAccess().getDatamartDefDatamartDefinitionCrossReference_1_0());
+ }
+
+)
+)(( otherlv_2='filter'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getTableBrokerDatamartAccess().getFilterKeyword_2_0_0());
+ }
+(
+(
+ lv_filter_3_0=RULE_STRING
+ {
+ newLeafNode(lv_filter_3_0, grammarAccess.getTableBrokerDatamartAccess().getFilterSTRINGTerminalRuleCall_2_0_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableBrokerDatamartRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "filter",
+ lv_filter_3_0,
+ "STRING");
+ }
+
+)
+))
+ |( otherlv_4='referenced'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getTableBrokerDatamartAccess().getReferencedKeyword_2_1_0());
+ }
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableBrokerDatamartRule());
+ }
+ }
+ otherlv_5=RULE_ID
+ {
+ newLeafNode(otherlv_5, grammarAccess.getTableBrokerDatamartAccess().getReferenceLEntityReferenceCrossReference_2_1_1_0());
+ }
+
+)
+))))
+;
+
+
+
+
+
+// Entry rule entryRuleTableAxis
+entryRuleTableAxis returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableAxisRule()); }
+ iv_ruleTableAxis=ruleTableAxis
+ { $current=$iv_ruleTableAxis.current; }
+ EOF
+;
+
+// Rule TableAxis
+ruleTableAxis returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='axis'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTableAxisAccess().getAxisKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableAxisAccess().getAxisAxisEnumEnumRuleCall_1_0());
+ }
+ lv_axis_1_0=ruleAxisEnum {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableAxisRule());
+ }
+ set(
+ $current,
+ "axis",
+ lv_axis_1_0,
+ "AxisEnum");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+
+(
+ {
+ getUnorderedGroupHelper().enter(grammarAccess.getTableAxisAccess().getUnorderedGroup_2());
+ }
+ (
+ (
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableAxisAccess().getUnorderedGroup_2(), 0)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableAxisAccess().getUnorderedGroup_2(), 0);
+ }
+ ({true}?=>((
+(
+ lv_hasRowHeight_3_0= 'rowheight'
+ {
+ newLeafNode(lv_hasRowHeight_3_0, grammarAccess.getTableAxisAccess().getHasRowHeightRowheightKeyword_2_0_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableAxisRule());
+ }
+ setWithLastConsumed($current, "hasRowHeight", true, "rowheight");
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getTableAxisAccess().getRowHeightNumberParserRuleCall_2_0_1_0());
+ }
+ lv_rowHeight_4_0=ruleNumber {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableAxisRule());
+ }
+ set(
+ $current,
+ "rowHeight",
+ lv_rowHeight_4_0,
+ "Number");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableAxisAccess().getUnorderedGroup_2());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableAxisAccess().getUnorderedGroup_2(), 1)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableAxisAccess().getUnorderedGroup_2(), 1);
+ }
+ ({true}?=>(
+(
+ {
+ newCompositeNode(grammarAccess.getTableAxisAccess().getPreOrderTablePreorderParserRuleCall_2_1_0());
+ }
+ lv_preOrder_5_0=ruleTablePreorder {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableAxisRule());
+ }
+ set(
+ $current,
+ "preOrder",
+ lv_preOrder_5_0,
+ "TablePreorder");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableAxisAccess().getUnorderedGroup_2());
+ }
+ )
+ )
+
+ )*
+ )
+)
+ {
+ getUnorderedGroupHelper().leave(grammarAccess.getTableAxisAccess().getUnorderedGroup_2());
+ }
+
+)((
+(
+ lv_hasDetails_6_0= 'details'
+ {
+ newLeafNode(lv_hasDetails_6_0, grammarAccess.getTableAxisAccess().getHasDetailsDetailsKeyword_3_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableAxisRule());
+ }
+ setWithLastConsumed($current, "hasDetails", true, "details");
+ }
+
+)
+) otherlv_7='{'
+ {
+ newLeafNode(otherlv_7, grammarAccess.getTableAxisAccess().getLeftCurlyBracketKeyword_3_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableAxisAccess().getValuesTableValueParserRuleCall_3_2_0());
+ }
+ lv_values_8_0=ruleTableValue {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableAxisRule());
+ }
+ add(
+ $current,
+ "values",
+ lv_values_8_0,
+ "TableValue");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)* otherlv_9='}'
+ {
+ newLeafNode(otherlv_9, grammarAccess.getTableAxisAccess().getRightCurlyBracketKeyword_3_3());
+ }
+)?((
+(
+ lv_hasEvents_10_0= 'events'
+ {
+ newLeafNode(lv_hasEvents_10_0, grammarAccess.getTableAxisAccess().getHasEventsEventsKeyword_4_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableAxisRule());
+ }
+ setWithLastConsumed($current, "hasEvents", true, "events");
+ }
+
+)
+) otherlv_11='{'
+ {
+ newLeafNode(otherlv_11, grammarAccess.getTableAxisAccess().getLeftCurlyBracketKeyword_4_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableAxisAccess().getEventsTableEventParserRuleCall_4_2_0());
+ }
+ lv_events_12_0=ruleTableEvent {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableAxisRule());
+ }
+ add(
+ $current,
+ "events",
+ lv_events_12_0,
+ "TableEvent");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)* otherlv_13='}'
+ {
+ newLeafNode(otherlv_13, grammarAccess.getTableAxisAccess().getRightCurlyBracketKeyword_4_3());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleTableRangeElement
+entryRuleTableRangeElement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableRangeElementRule()); }
+ iv_ruleTableRangeElement=ruleTableRangeElement
+ { $current=$iv_ruleTableRangeElement.current; }
+ EOF
+;
+
+// Rule TableRangeElement
+ruleTableRangeElement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getTableRangeElementAccess().getTableTextColorParserRuleCall_0());
+ }
+ this_TableTextColor_0=ruleTableTextColor
+ {
+ $current = $this_TableTextColor_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTableRangeElementAccess().getTableCellColorParserRuleCall_1());
+ }
+ this_TableCellColor_1=ruleTableCellColor
+ {
+ $current = $this_TableCellColor_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTableRangeElementAccess().getTableIconParserRuleCall_2());
+ }
+ this_TableIcon_2=ruleTableIcon
+ {
+ $current = $this_TableIcon_2.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTableRangeElementAccess().getTableTrendParserRuleCall_3());
+ }
+ this_TableTrend_3=ruleTableTrend
+ {
+ $current = $this_TableTrend_3.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTableRangeElementAccess().getTableTooltipParserRuleCall_4());
+ }
+ this_TableTooltip_4=ruleTableTooltip
+ {
+ $current = $this_TableTooltip_4.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleTableTextColor
+entryRuleTableTextColor returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableTextColorRule()); }
+ iv_ruleTableTextColor=ruleTableTextColor
+ { $current=$iv_ruleTableTextColor.current; }
+ EOF
+;
+
+// Rule TableTextColor
+ruleTableTextColor returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='textcolor'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTableTextColorAccess().getTextcolorKeyword_0());
+ }
+(
+(
+ lv_rgb_1_0=RULE_STRING
+ {
+ newLeafNode(lv_rgb_1_0, grammarAccess.getTableTextColorAccess().getRgbSTRINGTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableTextColorRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "rgb",
+ lv_rgb_1_0,
+ "STRING");
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableCellColor
+entryRuleTableCellColor returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableCellColorRule()); }
+ iv_ruleTableCellColor=ruleTableCellColor
+ { $current=$iv_ruleTableCellColor.current; }
+ EOF
+;
+
+// Rule TableCellColor
+ruleTableCellColor returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='cellcolor'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTableCellColorAccess().getCellcolorKeyword_0());
+ }
+(
+(
+ lv_rgb_1_0=RULE_STRING
+ {
+ newLeafNode(lv_rgb_1_0, grammarAccess.getTableCellColorAccess().getRgbSTRINGTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableCellColorRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "rgb",
+ lv_rgb_1_0,
+ "STRING");
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableIcon
+entryRuleTableIcon returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableIconRule()); }
+ iv_ruleTableIcon=ruleTableIcon
+ { $current=$iv_ruleTableIcon.current; }
+ EOF
+;
+
+// Rule TableIcon
+ruleTableIcon returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='icon'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTableIconAccess().getIconKeyword_0());
+ }
+(
+(
+ lv_icon_1_0=RULE_STRING
+ {
+ newLeafNode(lv_icon_1_0, grammarAccess.getTableIconAccess().getIconSTRINGTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableIconRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "icon",
+ lv_icon_1_0,
+ "STRING");
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableTrend
+entryRuleTableTrend returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableTrendRule()); }
+ iv_ruleTableTrend=ruleTableTrend
+ { $current=$iv_ruleTableTrend.current; }
+ EOF
+;
+
+// Rule TableTrend
+ruleTableTrend returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='trend'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTableTrendAccess().getTrendKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableTrendAccess().getIconTrendIconEnumEnumRuleCall_1_0());
+ }
+ lv_icon_1_0=ruleTrendIconEnum {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableTrendRule());
+ }
+ set(
+ $current,
+ "icon",
+ lv_icon_1_0,
+ "TrendIconEnum");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableTooltip
+entryRuleTableTooltip returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableTooltipRule()); }
+ iv_ruleTableTooltip=ruleTableTooltip
+ { $current=$iv_ruleTableTooltip.current; }
+ EOF
+;
+
+// Rule TableTooltip
+ruleTableTooltip returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='tooltip'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTableTooltipAccess().getTooltipKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableTooltipAccess().getTooltipTRANSLATABLESTRINGParserRuleCall_1_0());
+ }
+ lv_tooltip_1_0=ruleTRANSLATABLESTRING {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableTooltipRule());
+ }
+ set(
+ $current,
+ "tooltip",
+ lv_tooltip_1_0,
+ "TRANSLATABLESTRING");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableImport
+entryRuleTableImport returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableImportRule()); }
+ iv_ruleTableImport=ruleTableImport
+ { $current=$iv_ruleTableImport.current; }
+ EOF
+;
+
+// Rule TableImport
+ruleTableImport returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='import'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTableImportAccess().getImportKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableImportAccess().getImportedNamespaceTableQualifiedNameWithWildCardParserRuleCall_1_0());
+ }
+ lv_importedNamespace_1_0=ruleTableQualifiedNameWithWildCard {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableImportRule());
+ }
+ set(
+ $current,
+ "importedNamespace",
+ lv_importedNamespace_1_0,
+ "TableQualifiedNameWithWildCard");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTableGrid
+entryRuleTableGrid returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableGridRule()); }
+ iv_ruleTableGrid=ruleTableGrid
+ { $current=$iv_ruleTableGrid.current; }
+ EOF
+;
+
+// Rule TableGrid
+ruleTableGrid returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTableGridAccess().getTableGridAction_0(),
+ $current);
+ }
+) otherlv_1='grid'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableGridAccess().getGridKeyword_1());
+ }
+(
+
+(
+ {
+ getUnorderedGroupHelper().enter(grammarAccess.getTableGridAccess().getUnorderedGroup_2());
+ }
+ (
+ (
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableGridAccess().getUnorderedGroup_2(), 0)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableGridAccess().getUnorderedGroup_2(), 0);
+ }
+ ({true}?=>(
+(
+ lv_selectalways_3_0= 'selectalways'
+ {
+ newLeafNode(lv_selectalways_3_0, grammarAccess.getTableGridAccess().getSelectalwaysSelectalwaysKeyword_2_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableGridRule());
+ }
+ setWithLastConsumed($current, "selectalways", true, "selectalways");
+ }
+
+)
+))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableGridAccess().getUnorderedGroup_2());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableGridAccess().getUnorderedGroup_2(), 1)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableGridAccess().getUnorderedGroup_2(), 1);
+ }
+ ({true}?=>( otherlv_4='rowheader'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getTableGridAccess().getRowheaderKeyword_2_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableGridAccess().getHeaderModeRowHeaderModeEnumRuleCall_2_1_1_0());
+ }
+ lv_headerMode_5_0=ruleRowHeaderMode {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableGridRule());
+ }
+ set(
+ $current,
+ "headerMode",
+ lv_headerMode_5_0,
+ "RowHeaderMode");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableGridAccess().getUnorderedGroup_2());
+ }
+ )
+ )
+
+ )*
+ )
+)
+ {
+ getUnorderedGroupHelper().leave(grammarAccess.getTableGridAccess().getUnorderedGroup_2());
+ }
+
+)(
+
+(
+ {
+ getUnorderedGroupHelper().enter(grammarAccess.getTableGridAccess().getUnorderedGroup_3());
+ }
+ (
+ (
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableGridAccess().getUnorderedGroup_3(), 0)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableGridAccess().getUnorderedGroup_3(), 0);
+ }
+ ({true}?=>((
+(
+ lv_polling_7_0= 'polling'
+ {
+ newLeafNode(lv_polling_7_0, grammarAccess.getTableGridAccess().getPollingPollingKeyword_3_0_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableGridRule());
+ }
+ setWithLastConsumed($current, "polling", true, "polling");
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getTableGridAccess().getPollingTimeNumberParserRuleCall_3_0_1_0());
+ }
+ lv_pollingTime_8_0=ruleNumber {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableGridRule());
+ }
+ set(
+ $current,
+ "pollingTime",
+ lv_pollingTime_8_0,
+ "Number");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableGridAccess().getUnorderedGroup_3());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableGridAccess().getUnorderedGroup_3(), 1)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableGridAccess().getUnorderedGroup_3(), 1);
+ }
+ ({true}?=>(
+(
+ lv_filtering_9_0= 'filtering'
+ {
+ newLeafNode(lv_filtering_9_0, grammarAccess.getTableGridAccess().getFilteringFilteringKeyword_3_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableGridRule());
+ }
+ setWithLastConsumed($current, "filtering", true, "filtering");
+ }
+
+)
+))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableGridAccess().getUnorderedGroup_3());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableGridAccess().getUnorderedGroup_3(), 2)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableGridAccess().getUnorderedGroup_3(), 2);
+ }
+ ({true}?=>(
+(
+ lv_embedded_10_0= 'embedded'
+ {
+ newLeafNode(lv_embedded_10_0, grammarAccess.getTableGridAccess().getEmbeddedEmbeddedKeyword_3_2_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableGridRule());
+ }
+ setWithLastConsumed($current, "embedded", true, "embedded");
+ }
+
+)
+))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableGridAccess().getUnorderedGroup_3());
+ }
+ )
+ ) |
+
+ (
+ {getUnorderedGroupHelper().canSelect(grammarAccess.getTableGridAccess().getUnorderedGroup_3(), 3)}?=>(
+ {
+ getUnorderedGroupHelper().select(grammarAccess.getTableGridAccess().getUnorderedGroup_3(), 3);
+ }
+ ({true}?=>( otherlv_11='toolbar'
+ {
+ newLeafNode(otherlv_11, grammarAccess.getTableGridAccess().getToolbarKeyword_3_3_0());
+ }
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableGridRule());
+ }
+ }
+ otherlv_12=RULE_ID
+ {
+ newLeafNode(otherlv_12, grammarAccess.getTableGridAccess().getToolbarActionToolbarCrossReference_3_3_1_0());
+ }
+
+)
+)))
+ {
+ getUnorderedGroupHelper().returnFromSelection(grammarAccess.getTableGridAccess().getUnorderedGroup_3());
+ }
+ )
+ )
+
+ )*
+ )
+)
+ {
+ getUnorderedGroupHelper().leave(grammarAccess.getTableGridAccess().getUnorderedGroup_3());
+ }
+
+)( otherlv_13='using'
+ {
+ newLeafNode(otherlv_13, grammarAccess.getTableGridAccess().getUsingKeyword_4_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableGridAccess().getSourceTableDtoDatasourceParserRuleCall_4_1_0());
+ }
+ lv_source_14_0=ruleTableDtoDatasource {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableGridRule());
+ }
+ set(
+ $current,
+ "source",
+ lv_source_14_0,
+ "TableDtoDatasource");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleTableDtoDatasource
+entryRuleTableDtoDatasource returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableDtoDatasourceRule()); }
+ iv_ruleTableDtoDatasource=ruleTableDtoDatasource
+ { $current=$iv_ruleTableDtoDatasource.current; }
+ EOF
+;
+
+// Rule TableDtoDatasource
+ruleTableDtoDatasource returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='dto'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTableDtoDatasourceAccess().getDtoKeyword_0());
+ }
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTableDtoDatasourceRule());
+ }
+ }
+ otherlv_1=RULE_ID
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTableDtoDatasourceAccess().getDtoSourceLDtoCrossReference_1_0());
+ }
+
+)
+)( otherlv_2='{'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getTableDtoDatasourceAccess().getLeftCurlyBracketKeyword_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTableDtoDatasourceAccess().getPropertiesPropertyParserRuleCall_2_1_0());
+ }
+ lv_properties_3_0=ruleProperty {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTableDtoDatasourceRule());
+ }
+ add(
+ $current,
+ "properties",
+ lv_properties_3_0,
+ "Property");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)* otherlv_4='}'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getTableDtoDatasourceAccess().getRightCurlyBracketKeyword_2_2());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleProperty
+entryRuleProperty returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyRule()); }
+ iv_ruleProperty=ruleProperty
+ { $current=$iv_ruleProperty.current; }
+ EOF
+;
+
+// Rule Property
+ruleProperty returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_editable_0_0= 'editable'
+ {
+ newLeafNode(lv_editable_0_0, grammarAccess.getPropertyAccess().getEditableEditableKeyword_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getPropertyRule());
+ }
+ setWithLastConsumed($current, "editable", true, "editable");
+ }
+
+)
+)? otherlv_1='prop'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPropertyAccess().getPropKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyAccess().getPathNestedFieldParserRuleCall_2_0());
+ }
+ lv_path_2_0=ruleNestedField {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPropertyRule());
+ }
+ set(
+ $current,
+ "path",
+ lv_path_2_0,
+ "NestedField");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_3='style'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getPropertyAccess().getStyleKeyword_3());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyAccess().getStylePropertyStyleParserRuleCall_4_0());
+ }
+ lv_style_4_0=rulePropertyStyle {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPropertyRule());
+ }
+ set(
+ $current,
+ "style",
+ lv_style_4_0,
+ "PropertyStyle");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleNestedField
+entryRuleNestedField returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNestedFieldRule()); }
+ iv_ruleNestedField=ruleNestedField
+ { $current=$iv_ruleNestedField.current; }
+ EOF
+;
+
+// Rule NestedField
+ruleNestedField returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getNestedFieldAccess().getCxGridNestedFieldAction_0(),
+ $current);
+ }
+)(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getNestedFieldRule());
+ }
+ }
+ otherlv_1=RULE_ID
+ {
+ newLeafNode(otherlv_1, grammarAccess.getNestedFieldAccess().getFieldJvmOperationCrossReference_1_0());
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getNestedFieldAccess().getPathNestedPathParserRuleCall_2_0());
+ }
+ lv_path_2_0=ruleNestedPath {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNestedFieldRule());
+ }
+ set(
+ $current,
+ "path",
+ lv_path_2_0,
+ "NestedPath");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleNestedPath
+entryRuleNestedPath returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNestedPathRule()); }
+ iv_ruleNestedPath=ruleNestedPath
+ { $current=$iv_ruleNestedPath.current; }
+ EOF
+;
+
+// Rule NestedPath
+ruleNestedPath returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getNestedPathAccess().getCxGridNestedPathAction_0(),
+ $current);
+ }
+) otherlv_1='.'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getNestedPathAccess().getFullStopKeyword_1());
+ }
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getNestedPathRule());
+ }
+ }
+ otherlv_2=RULE_ID
+ {
+ newLeafNode(otherlv_2, grammarAccess.getNestedPathAccess().getFieldJvmOperationCrossReference_2_0());
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getNestedPathAccess().getPathNestedPathParserRuleCall_3_0());
+ }
+ lv_path_3_0=ruleNestedPath {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNestedPathRule());
+ }
+ set(
+ $current,
+ "path",
+ lv_path_3_0,
+ "NestedPath");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRulePropertyStyle
+entryRulePropertyStyle returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyStyleRule()); }
+ iv_rulePropertyStyle=rulePropertyStyle
+ { $current=$iv_rulePropertyStyle.current; }
+ EOF
+;
+
+// Rule PropertyStyle
+rulePropertyStyle returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyStyleAccess().getPropertyButtonStyleParserRuleCall_0());
+ }
+ this_PropertyButtonStyle_0=rulePropertyButtonStyle
+ {
+ $current = $this_PropertyButtonStyle_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPropertyStyleAccess().getPropertyHtmlStyleParserRuleCall_1());
+ }
+ this_PropertyHtmlStyle_1=rulePropertyHtmlStyle
+ {
+ $current = $this_PropertyHtmlStyle_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPropertyStyleAccess().getPropertyProgressbarStyleParserRuleCall_2());
+ }
+ this_PropertyProgressbarStyle_2=rulePropertyProgressbarStyle
+ {
+ $current = $this_PropertyProgressbarStyle_2.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPropertyStyleAccess().getPropertyTextStyleParserRuleCall_3());
+ }
+ this_PropertyTextStyle_3=rulePropertyTextStyle
+ {
+ $current = $this_PropertyTextStyle_3.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPropertyStyleAccess().getPropertyBooleanStyleParserRuleCall_4());
+ }
+ this_PropertyBooleanStyle_4=rulePropertyBooleanStyle
+ {
+ $current = $this_PropertyBooleanStyle_4.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPropertyStyleAccess().getPropertyDateStyleParserRuleCall_5());
+ }
+ this_PropertyDateStyle_5=rulePropertyDateStyle
+ {
+ $current = $this_PropertyDateStyle_5.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPropertyStyleAccess().getPropertyNumberStyleParserRuleCall_6());
+ }
+ this_PropertyNumberStyle_6=rulePropertyNumberStyle
+ {
+ $current = $this_PropertyNumberStyle_6.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPropertyStyleAccess().getPropertyImageStyleParserRuleCall_7());
+ }
+ this_PropertyImageStyle_7=rulePropertyImageStyle
+ {
+ $current = $this_PropertyImageStyle_7.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPropertyStyleAccess().getPropertyQuantityStyleParserRuleCall_8());
+ }
+ this_PropertyQuantityStyle_8=rulePropertyQuantityStyle
+ {
+ $current = $this_PropertyQuantityStyle_8.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPropertyStyleAccess().getPropertyPriceStyleParserRuleCall_9());
+ }
+ this_PropertyPriceStyle_9=rulePropertyPriceStyle
+ {
+ $current = $this_PropertyPriceStyle_9.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPropertyStyleAccess().getGridPropIndicatorStyleParserRuleCall_10());
+ }
+ this_GridPropIndicatorStyle_10=ruleGridPropIndicatorStyle
+ {
+ $current = $this_GridPropIndicatorStyle_10.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRulePropertyButtonStyle
+entryRulePropertyButtonStyle returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyButtonStyleRule()); }
+ iv_rulePropertyButtonStyle=rulePropertyButtonStyle
+ { $current=$iv_rulePropertyButtonStyle.current; }
+ EOF
+;
+
+// Rule PropertyButtonStyle
+rulePropertyButtonStyle returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPropertyButtonStyleAccess().getCxGridPropButtonStyleAction_0(),
+ $current);
+ }
+) otherlv_1='buttonStyle'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPropertyButtonStyleAccess().getButtonStyleKeyword_1());
+ }
+ otherlv_2='eventTopic'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getPropertyButtonStyleAccess().getEventTopicKeyword_2());
+ }
+(
+(
+ lv_eventTopic_3_0=RULE_STRING
+ {
+ newLeafNode(lv_eventTopic_3_0, grammarAccess.getPropertyButtonStyleAccess().getEventTopicSTRINGTerminalRuleCall_3_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getPropertyButtonStyleRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "eventTopic",
+ lv_eventTopic_3_0,
+ "STRING");
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRulePropertyHtmlStyle
+entryRulePropertyHtmlStyle returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyHtmlStyleRule()); }
+ iv_rulePropertyHtmlStyle=rulePropertyHtmlStyle
+ { $current=$iv_rulePropertyHtmlStyle.current; }
+ EOF
+;
+
+// Rule PropertyHtmlStyle
+rulePropertyHtmlStyle returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPropertyHtmlStyleAccess().getCxGridPropHtmlStyleAction_0(),
+ $current);
+ }
+) otherlv_1='htmlStyle'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPropertyHtmlStyleAccess().getHtmlStyleKeyword_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRulePropertyBooleanStyle
+entryRulePropertyBooleanStyle returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyBooleanStyleRule()); }
+ iv_rulePropertyBooleanStyle=rulePropertyBooleanStyle
+ { $current=$iv_rulePropertyBooleanStyle.current; }
+ EOF
+;
+
+// Rule PropertyBooleanStyle
+rulePropertyBooleanStyle returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPropertyBooleanStyleAccess().getCxGridPropBooleanStyleAction_0(),
+ $current);
+ }
+) otherlv_1='boolStyle'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPropertyBooleanStyleAccess().getBoolStyleKeyword_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRulePropertyDateStyle
+entryRulePropertyDateStyle returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyDateStyleRule()); }
+ iv_rulePropertyDateStyle=rulePropertyDateStyle
+ { $current=$iv_rulePropertyDateStyle.current; }
+ EOF
+;
+
+// Rule PropertyDateStyle
+rulePropertyDateStyle returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPropertyDateStyleAccess().getCxGridPropDateStyleAction_0(),
+ $current);
+ }
+) otherlv_1='dateStyle'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPropertyDateStyleAccess().getDateStyleKeyword_1());
+ }
+ otherlv_2='format'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getPropertyDateStyleAccess().getFormatKeyword_2());
+ }
+(
+(
+ lv_dateFormat_3_0=RULE_STRING
+ {
+ newLeafNode(lv_dateFormat_3_0, grammarAccess.getPropertyDateStyleAccess().getDateFormatSTRINGTerminalRuleCall_3_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getPropertyDateStyleRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "dateFormat",
+ lv_dateFormat_3_0,
+ "STRING");
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRulePropertyNumberStyle
+entryRulePropertyNumberStyle returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyNumberStyleRule()); }
+ iv_rulePropertyNumberStyle=rulePropertyNumberStyle
+ { $current=$iv_rulePropertyNumberStyle.current; }
+ EOF
+;
+
+// Rule PropertyNumberStyle
+rulePropertyNumberStyle returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPropertyNumberStyleAccess().getCxGridPropNumberStyleAction_0(),
+ $current);
+ }
+) otherlv_1='numberStyle'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPropertyNumberStyleAccess().getNumberStyleKeyword_1());
+ }
+ otherlv_2='format'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getPropertyNumberStyleAccess().getFormatKeyword_2());
+ }
+(
+(
+ lv_numberFormat_3_0=RULE_STRING
+ {
+ newLeafNode(lv_numberFormat_3_0, grammarAccess.getPropertyNumberStyleAccess().getNumberFormatSTRINGTerminalRuleCall_3_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getPropertyNumberStyleRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "numberFormat",
+ lv_numberFormat_3_0,
+ "STRING");
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRulePropertyProgressbarStyle
+entryRulePropertyProgressbarStyle returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyProgressbarStyleRule()); }
+ iv_rulePropertyProgressbarStyle=rulePropertyProgressbarStyle
+ { $current=$iv_rulePropertyProgressbarStyle.current; }
+ EOF
+;
+
+// Rule PropertyProgressbarStyle
+rulePropertyProgressbarStyle returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPropertyProgressbarStyleAccess().getCxGridPropProgressbarStyleAction_0(),
+ $current);
+ }
+) otherlv_1='progressbarStyle'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPropertyProgressbarStyleAccess().getProgressbarStyleKeyword_1());
+ }
+ otherlv_2='max'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getPropertyProgressbarStyleAccess().getMaxKeyword_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyProgressbarStyleAccess().getMaxValueLDoubleParserRuleCall_3_0());
+ }
+ lv_maxValue_3_0=ruleLDouble {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPropertyProgressbarStyleRule());
+ }
+ set(
+ $current,
+ "maxValue",
+ lv_maxValue_3_0,
+ "LDouble");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleGridPropIndicatorStyle
+entryRuleGridPropIndicatorStyle returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getGridPropIndicatorStyleRule()); }
+ iv_ruleGridPropIndicatorStyle=ruleGridPropIndicatorStyle
+ { $current=$iv_ruleGridPropIndicatorStyle.current; }
+ EOF
+;
+
+// Rule GridPropIndicatorStyle
+ruleGridPropIndicatorStyle returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getGridPropIndicatorStyleAccess().getCxGridPropIndicatorStyleAction_0(),
+ $current);
+ }
+) otherlv_1='indicatorStyle'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getGridPropIndicatorStyleAccess().getIndicatorStyleKeyword_1());
+ }
+ otherlv_2='greenFrom'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getGridPropIndicatorStyleAccess().getGreenFromKeyword_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getGridPropIndicatorStyleAccess().getGreenStartsLDoubleParserRuleCall_3_0());
+ }
+ lv_greenStarts_3_0=ruleLDouble {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getGridPropIndicatorStyleRule());
+ }
+ set(
+ $current,
+ "greenStarts",
+ lv_greenStarts_3_0,
+ "LDouble");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_4='redUntil'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getGridPropIndicatorStyleAccess().getRedUntilKeyword_4());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getGridPropIndicatorStyleAccess().getRedEndsLDoubleParserRuleCall_5_0());
+ }
+ lv_redEnds_5_0=ruleLDouble {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getGridPropIndicatorStyleRule());
+ }
+ set(
+ $current,
+ "redEnds",
+ lv_redEnds_5_0,
+ "LDouble");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRulePropertyQuantityStyle
+entryRulePropertyQuantityStyle returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyQuantityStyleRule()); }
+ iv_rulePropertyQuantityStyle=rulePropertyQuantityStyle
+ { $current=$iv_rulePropertyQuantityStyle.current; }
+ EOF
+;
+
+// Rule PropertyQuantityStyle
+rulePropertyQuantityStyle returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPropertyQuantityStyleAccess().getCxGridPropQuantityStyleAction_0(),
+ $current);
+ }
+) otherlv_1='quantityStyle'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPropertyQuantityStyleAccess().getQuantityStyleKeyword_1());
+ }
+(
+(
+ lv_htmlPattern_2_0=RULE_STRING
+ {
+ newLeafNode(lv_htmlPattern_2_0, grammarAccess.getPropertyQuantityStyleAccess().getHtmlPatternSTRINGTerminalRuleCall_2_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getPropertyQuantityStyleRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "htmlPattern",
+ lv_htmlPattern_2_0,
+ "STRING");
+ }
+
+)
+)? otherlv_3='value'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getPropertyQuantityStyleAccess().getValueKeyword_3());
+ }
+ otherlv_4='='
+ {
+ newLeafNode(otherlv_4, grammarAccess.getPropertyQuantityStyleAccess().getEqualsSignKeyword_4());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyQuantityStyleAccess().getValuePropertyPathNestedFieldParserRuleCall_5_0());
+ }
+ lv_valuePropertyPath_5_0=ruleNestedField {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPropertyQuantityStyleRule());
+ }
+ set(
+ $current,
+ "valuePropertyPath",
+ lv_valuePropertyPath_5_0,
+ "NestedField");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_6='('
+ {
+ newLeafNode(otherlv_6, grammarAccess.getPropertyQuantityStyleAccess().getLeftParenthesisKeyword_6_0());
+ }
+ otherlv_7='format'
+ {
+ newLeafNode(otherlv_7, grammarAccess.getPropertyQuantityStyleAccess().getFormatKeyword_6_1());
+ }
+(
+(
+ lv_valueNumberFormat_8_0=RULE_STRING
+ {
+ newLeafNode(lv_valueNumberFormat_8_0, grammarAccess.getPropertyQuantityStyleAccess().getValueNumberFormatSTRINGTerminalRuleCall_6_2_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getPropertyQuantityStyleRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "valueNumberFormat",
+ lv_valueNumberFormat_8_0,
+ "STRING");
+ }
+
+)
+) otherlv_9=')'
+ {
+ newLeafNode(otherlv_9, grammarAccess.getPropertyQuantityStyleAccess().getRightParenthesisKeyword_6_3());
+ }
+)? otherlv_10='uom'
+ {
+ newLeafNode(otherlv_10, grammarAccess.getPropertyQuantityStyleAccess().getUomKeyword_7());
+ }
+ otherlv_11='='
+ {
+ newLeafNode(otherlv_11, grammarAccess.getPropertyQuantityStyleAccess().getEqualsSignKeyword_8());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyQuantityStyleAccess().getUomPropertyPathNestedFieldParserRuleCall_9_0());
+ }
+ lv_uomPropertyPath_12_0=ruleNestedField {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPropertyQuantityStyleRule());
+ }
+ set(
+ $current,
+ "uomPropertyPath",
+ lv_uomPropertyPath_12_0,
+ "NestedField");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRulePropertyPriceStyle
+entryRulePropertyPriceStyle returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyPriceStyleRule()); }
+ iv_rulePropertyPriceStyle=rulePropertyPriceStyle
+ { $current=$iv_rulePropertyPriceStyle.current; }
+ EOF
+;
+
+// Rule PropertyPriceStyle
+rulePropertyPriceStyle returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPropertyPriceStyleAccess().getCxGridPropPriceStyleAction_0(),
+ $current);
+ }
+) otherlv_1='priceStyle'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPropertyPriceStyleAccess().getPriceStyleKeyword_1());
+ }
+(
+(
+ lv_htmlPattern_2_0=RULE_STRING
+ {
+ newLeafNode(lv_htmlPattern_2_0, grammarAccess.getPropertyPriceStyleAccess().getHtmlPatternSTRINGTerminalRuleCall_2_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getPropertyPriceStyleRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "htmlPattern",
+ lv_htmlPattern_2_0,
+ "STRING");
+ }
+
+)
+)? otherlv_3='value'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getPropertyPriceStyleAccess().getValueKeyword_3());
+ }
+ otherlv_4='='
+ {
+ newLeafNode(otherlv_4, grammarAccess.getPropertyPriceStyleAccess().getEqualsSignKeyword_4());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyPriceStyleAccess().getValuePropertyPathNestedFieldParserRuleCall_5_0());
+ }
+ lv_valuePropertyPath_5_0=ruleNestedField {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPropertyPriceStyleRule());
+ }
+ set(
+ $current,
+ "valuePropertyPath",
+ lv_valuePropertyPath_5_0,
+ "NestedField");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_6='('
+ {
+ newLeafNode(otherlv_6, grammarAccess.getPropertyPriceStyleAccess().getLeftParenthesisKeyword_6_0());
+ }
+ otherlv_7='format'
+ {
+ newLeafNode(otherlv_7, grammarAccess.getPropertyPriceStyleAccess().getFormatKeyword_6_1());
+ }
+(
+(
+ lv_valueNumberFormat_8_0=RULE_STRING
+ {
+ newLeafNode(lv_valueNumberFormat_8_0, grammarAccess.getPropertyPriceStyleAccess().getValueNumberFormatSTRINGTerminalRuleCall_6_2_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getPropertyPriceStyleRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "valueNumberFormat",
+ lv_valueNumberFormat_8_0,
+ "STRING");
+ }
+
+)
+) otherlv_9=')'
+ {
+ newLeafNode(otherlv_9, grammarAccess.getPropertyPriceStyleAccess().getRightParenthesisKeyword_6_3());
+ }
+)? otherlv_10='currency'
+ {
+ newLeafNode(otherlv_10, grammarAccess.getPropertyPriceStyleAccess().getCurrencyKeyword_7());
+ }
+ otherlv_11='='
+ {
+ newLeafNode(otherlv_11, grammarAccess.getPropertyPriceStyleAccess().getEqualsSignKeyword_8());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyPriceStyleAccess().getCurrencyPropertyPathNestedFieldParserRuleCall_9_0());
+ }
+ lv_currencyPropertyPath_12_0=ruleNestedField {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPropertyPriceStyleRule());
+ }
+ set(
+ $current,
+ "currencyPropertyPath",
+ lv_currencyPropertyPath_12_0,
+ "NestedField");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRulePropertyTextStyle
+entryRulePropertyTextStyle returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyTextStyleRule()); }
+ iv_rulePropertyTextStyle=rulePropertyTextStyle
+ { $current=$iv_rulePropertyTextStyle.current; }
+ EOF
+;
+
+// Rule PropertyTextStyle
+rulePropertyTextStyle returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPropertyTextStyleAccess().getCxGridPropTextStyleAction_0(),
+ $current);
+ }
+) otherlv_1='textStyle'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPropertyTextStyleAccess().getTextStyleKeyword_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRulePropertyImageStyle
+entryRulePropertyImageStyle returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyImageStyleRule()); }
+ iv_rulePropertyImageStyle=rulePropertyImageStyle
+ { $current=$iv_rulePropertyImageStyle.current; }
+ EOF
+;
+
+// Rule PropertyImageStyle
+rulePropertyImageStyle returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPropertyImageStyleAccess().getCxGridPropImageStyleAction_0(),
+ $current);
+ }
+) otherlv_1='imageStyle'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPropertyImageStyleAccess().getImageStyleKeyword_1());
+ }
+( otherlv_2='eventTopic'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getPropertyImageStyleAccess().getEventTopicKeyword_2_0());
+ }
+(
+(
+ lv_eventTopic_3_0=RULE_STRING
+ {
+ newLeafNode(lv_eventTopic_3_0, grammarAccess.getPropertyImageStyleAccess().getEventTopicSTRINGTerminalRuleCall_2_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getPropertyImageStyleRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "eventTopic",
+ lv_eventTopic_3_0,
+ "STRING");
+ }
+
+)
+))? otherlv_4='{'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getPropertyImageStyleAccess().getLeftCurlyBracketKeyword_3());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyImageStyleAccess().getConfigsStyleConfigParserRuleCall_4_0());
+ }
+ lv_configs_5_0=ruleStyleConfig {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPropertyImageStyleRule());
+ }
+ add(
+ $current,
+ "configs",
+ lv_configs_5_0,
+ "StyleConfig");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)* otherlv_6='}'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getPropertyImageStyleAccess().getRightCurlyBracketKeyword_5());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleStyleConfig
+entryRuleStyleConfig returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getStyleConfigRule()); }
+ iv_ruleStyleConfig=ruleStyleConfig
+ { $current=$iv_ruleStyleConfig.current; }
+ EOF
+;
+
+// Rule StyleConfig
+ruleStyleConfig returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getStyleConfigAccess().getNumericToResourceStyleConfigParserRuleCall_0());
+ }
+ this_NumericToResourceStyleConfig_0=ruleNumericToResourceStyleConfig
+ {
+ $current = $this_NumericToResourceStyleConfig_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStyleConfigAccess().getStringToResourceStyleConfigParserRuleCall_1());
+ }
+ this_StringToResourceStyleConfig_1=ruleStringToResourceStyleConfig
+ {
+ $current = $this_StringToResourceStyleConfig_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleNumericToResourceStyleConfig
+entryRuleNumericToResourceStyleConfig returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNumericToResourceStyleConfigRule()); }
+ iv_ruleNumericToResourceStyleConfig=ruleNumericToResourceStyleConfig
+ { $current=$iv_ruleNumericToResourceStyleConfig.current; }
+ EOF
+;
+
+// Rule NumericToResourceStyleConfig
+ruleNumericToResourceStyleConfig returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='number'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getNumericToResourceStyleConfigAccess().getNumberKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getNumericToResourceStyleConfigAccess().getCompareStyleCompareEnumRuleCall_1_0());
+ }
+ lv_compare_1_0=ruleStyleCompare {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNumericToResourceStyleConfigRule());
+ }
+ set(
+ $current,
+ "compare",
+ lv_compare_1_0,
+ "StyleCompare");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getNumericToResourceStyleConfigAccess().getValueLDoubleParserRuleCall_2_0());
+ }
+ lv_value_2_0=ruleLDouble {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNumericToResourceStyleConfigRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_2_0,
+ "LDouble");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_3='then'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getNumericToResourceStyleConfigAccess().getThenKeyword_3());
+ }
+(
+(
+ lv_resourceThemePath_4_0=RULE_THEME_RESOURCE
+ {
+ newLeafNode(lv_resourceThemePath_4_0, grammarAccess.getNumericToResourceStyleConfigAccess().getResourceThemePathTHEME_RESOURCETerminalRuleCall_4_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getNumericToResourceStyleConfigRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "resourceThemePath",
+ lv_resourceThemePath_4_0,
+ "THEME_RESOURCE");
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleStringToResourceStyleConfig
+entryRuleStringToResourceStyleConfig returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getStringToResourceStyleConfigRule()); }
+ iv_ruleStringToResourceStyleConfig=ruleStringToResourceStyleConfig
+ { $current=$iv_ruleStringToResourceStyleConfig.current; }
+ EOF
+;
+
+// Rule StringToResourceStyleConfig
+ruleStringToResourceStyleConfig returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='string'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getStringToResourceStyleConfigAccess().getStringKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getStringToResourceStyleConfigAccess().getCompareStyleCompareEnumRuleCall_1_0());
+ }
+ lv_compare_1_0=ruleStyleCompare {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getStringToResourceStyleConfigRule());
+ }
+ set(
+ $current,
+ "compare",
+ lv_compare_1_0,
+ "StyleCompare");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ lv_value_2_0=RULE_STRING
+ {
+ newLeafNode(lv_value_2_0, grammarAccess.getStringToResourceStyleConfigAccess().getValueSTRINGTerminalRuleCall_2_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getStringToResourceStyleConfigRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "value",
+ lv_value_2_0,
+ "STRING");
+ }
+
+)
+) otherlv_3='then'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getStringToResourceStyleConfigAccess().getThenKeyword_3());
+ }
+(
+(
+ lv_resourceThemePath_4_0=RULE_THEME_RESOURCE
+ {
+ newLeafNode(lv_resourceThemePath_4_0, grammarAccess.getStringToResourceStyleConfigAccess().getResourceThemePathTHEME_RESOURCETerminalRuleCall_4_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getStringToResourceStyleConfigRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "resourceThemePath",
+ lv_resourceThemePath_4_0,
+ "THEME_RESOURCE");
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleLInt
+entryRuleLInt returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getLIntRule()); }
+ iv_ruleLInt=ruleLInt
+ { $current=$iv_ruleLInt.current.getText(); }
+ EOF
+;
+
+// Rule LInt
+ruleLInt returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ kw='+'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getLIntAccess().getPlusSignKeyword_0_0());
+ }
+
+ |
+ kw='-'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getLIntAccess().getHyphenMinusKeyword_0_1());
+ }
+)? this_INT_2=RULE_INT {
+ $current.merge(this_INT_2);
+ }
+
+ {
+ newLeafNode(this_INT_2, grammarAccess.getLIntAccess().getINTTerminalRuleCall_1());
+ }
+)
+ ;
+
+
+
+
+
+// Entry rule entryRuleLDouble
+entryRuleLDouble returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getLDoubleRule()); }
+ iv_ruleLDouble=ruleLDouble
+ { $current=$iv_ruleLDouble.current.getText(); }
+ EOF
+;
+
+// Rule LDouble
+ruleLDouble returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getLDoubleAccess().getLIntParserRuleCall_0());
+ }
+ this_LInt_0=ruleLInt {
+ $current.merge(this_LInt_0);
+ }
+
+ {
+ afterParserOrEnumRuleCall();
+ }
+(
+ kw='.'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getLDoubleAccess().getFullStopKeyword_1_0());
+ }
+ this_INT_2=RULE_INT {
+ $current.merge(this_INT_2);
+ }
+
+ {
+ newLeafNode(this_INT_2, grammarAccess.getLDoubleAccess().getINTTerminalRuleCall_1_1());
+ }
+)?)
+ ;
+
+
+
+
+
+// Entry rule entryRuleSignedNumber
+entryRuleSignedNumber returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getSignedNumberRule()); }
+ iv_ruleSignedNumber=ruleSignedNumber
+ { $current=$iv_ruleSignedNumber.current.getText(); }
+ EOF
+;
+
+// Rule SignedNumber
+ruleSignedNumber returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ kw='-'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getSignedNumberAccess().getHyphenMinusKeyword_0());
+ }
+)?
+ {
+ newCompositeNode(grammarAccess.getSignedNumberAccess().getNumberParserRuleCall_1());
+ }
+ this_Number_1=ruleNumber {
+ $current.merge(this_Number_1);
+ }
+
+ {
+ afterParserOrEnumRuleCall();
+ }
+)
+ ;
+
+
+
+
+
+// Entry rule entryRuleTableQualifiedNameWithWildCard
+entryRuleTableQualifiedNameWithWildCard returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getTableQualifiedNameWithWildCardRule()); }
+ iv_ruleTableQualifiedNameWithWildCard=ruleTableQualifiedNameWithWildCard
+ { $current=$iv_ruleTableQualifiedNameWithWildCard.current.getText(); }
+ EOF
+;
+
+// Rule TableQualifiedNameWithWildCard
+ruleTableQualifiedNameWithWildCard returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getTableQualifiedNameWithWildCardAccess().getQualifiedNameParserRuleCall_0());
+ }
+ this_QualifiedName_0=ruleQualifiedName {
+ $current.merge(this_QualifiedName_0);
+ }
+
+ {
+ afterParserOrEnumRuleCall();
+ }
+(
+ kw='.'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getTableQualifiedNameWithWildCardAccess().getFullStopKeyword_1_0());
+ }
+
+ kw='*'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getTableQualifiedNameWithWildCardAccess().getAsteriskKeyword_1_1());
+ }
+)?)
+ ;
+
+
+
+
+
+// Entry rule entryRuleQualifiedName
+entryRuleQualifiedName returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getQualifiedNameRule()); }
+ iv_ruleQualifiedName=ruleQualifiedName
+ { $current=$iv_ruleQualifiedName.current.getText(); }
+ EOF
+;
+
+// Rule QualifiedName
+ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0());
+ }
+ this_ValidID_0=ruleValidID {
+ $current.merge(this_ValidID_0);
+ }
+
+ {
+ afterParserOrEnumRuleCall();
+ }
+(((
+ '.'
+)=>
+ kw='.'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0());
+ }
+)
+ {
+ newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1());
+ }
+ this_ValidID_2=ruleValidID {
+ $current.merge(this_ValidID_2);
+ }
+
+ {
+ afterParserOrEnumRuleCall();
+ }
+)*)
+ ;
+
+
+
+
+
+// Entry rule entryRuleValidID
+entryRuleValidID returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getValidIDRule()); }
+ iv_ruleValidID=ruleValidID
+ { $current=$iv_ruleValidID.current.getText(); }
+ EOF
+;
+
+// Rule ValidID
+ruleValidID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+ this_ID_0=RULE_ID {
+ $current.merge(this_ID_0);
+ }
+
+ {
+ newLeafNode(this_ID_0, grammarAccess.getValidIDAccess().getIDTerminalRuleCall());
+ }
+
+ ;
+
+
+
+
+
+// Entry rule entryRuleTRANSLATABLESTRING
+entryRuleTRANSLATABLESTRING returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getTRANSLATABLESTRINGRule()); }
+ iv_ruleTRANSLATABLESTRING=ruleTRANSLATABLESTRING
+ { $current=$iv_ruleTRANSLATABLESTRING.current.getText(); }
+ EOF
+;
+
+// Rule TRANSLATABLESTRING
+ruleTRANSLATABLESTRING returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+ this_STRING_0=RULE_STRING {
+ $current.merge(this_STRING_0);
+ }
+
+ {
+ newLeafNode(this_STRING_0, grammarAccess.getTRANSLATABLESTRINGAccess().getSTRINGTerminalRuleCall());
+ }
+
+ ;
+
+
+
+
+
+// Entry rule entryRuleTRANSLATABLEID
+entryRuleTRANSLATABLEID returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getTRANSLATABLEIDRule()); }
+ iv_ruleTRANSLATABLEID=ruleTRANSLATABLEID
+ { $current=$iv_ruleTRANSLATABLEID.current.getText(); }
+ EOF
+;
+
+// Rule TRANSLATABLEID
+ruleTRANSLATABLEID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+ this_ID_0=RULE_ID {
+ $current.merge(this_ID_0);
+ }
+
+ {
+ newLeafNode(this_ID_0, grammarAccess.getTRANSLATABLEIDAccess().getIDTerminalRuleCall());
+ }
+
+ ;
+
+
+
+
+
+// Entry rule entryRuleXAnnotation
+entryRuleXAnnotation returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXAnnotationRule()); }
+ iv_ruleXAnnotation=ruleXAnnotation
+ { $current=$iv_ruleXAnnotation.current; }
+ EOF
+;
+
+// Rule XAnnotation
+ruleXAnnotation returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXAnnotationAccess().getXAnnotationAction_0(),
+ $current);
+ }
+) otherlv_1='@'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXAnnotationAccess().getCommercialAtKeyword_1());
+ }
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXAnnotationRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeCrossReference_2_0());
+ }
+ ruleQualifiedName {
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((( '('
+)=> otherlv_3='('
+ {
+ newLeafNode(otherlv_3, grammarAccess.getXAnnotationAccess().getLeftParenthesisKeyword_3_0());
+ }
+)((((((
+(
+ ruleValidID
+)
+) '='
+))=>
+(
+ {
+ newCompositeNode(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_0_0());
+ }
+ lv_elementValuePairs_4_0=ruleXAnnotationElementValuePair {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationRule());
+ }
+ add(
+ $current,
+ "elementValuePairs",
+ lv_elementValuePairs_4_0,
+ "XAnnotationElementValuePair");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_5=','
+ {
+ newLeafNode(otherlv_5, grammarAccess.getXAnnotationAccess().getCommaKeyword_3_1_0_1_0());
+ }
+((((
+(
+ ruleValidID
+)
+) '='
+))=>
+(
+ {
+ newCompositeNode(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_1_1_0());
+ }
+ lv_elementValuePairs_6_0=ruleXAnnotationElementValuePair {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationRule());
+ }
+ add(
+ $current,
+ "elementValuePairs",
+ lv_elementValuePairs_6_0,
+ "XAnnotationElementValuePair");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getXAnnotationAccess().getValueXAnnotationElementValueOrCommaListParserRuleCall_3_1_1_0());
+ }
+ lv_value_7_0=ruleXAnnotationElementValueOrCommaList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_7_0,
+ "XAnnotationElementValueOrCommaList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))? otherlv_8=')'
+ {
+ newLeafNode(otherlv_8, grammarAccess.getXAnnotationAccess().getRightParenthesisKeyword_3_2());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleXAnnotationElementValuePair
+entryRuleXAnnotationElementValuePair returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXAnnotationElementValuePairRule()); }
+ iv_ruleXAnnotationElementValuePair=ruleXAnnotationElementValuePair
+ { $current=$iv_ruleXAnnotationElementValuePair.current; }
+ EOF
+;
+
+// Rule XAnnotationElementValuePair
+ruleXAnnotationElementValuePair returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((((
+(
+ ruleValidID
+)
+) '='
+))=>((
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXAnnotationElementValuePairRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationCrossReference_0_0_0_0());
+ }
+ ruleValidID {
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_1='='
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXAnnotationElementValuePairAccess().getEqualsSignKeyword_0_0_1());
+ }
+))(
+(
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValuePairAccess().getValueXAnnotationElementValueParserRuleCall_1_0());
+ }
+ lv_value_2_0=ruleXAnnotationElementValue {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationElementValuePairRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_2_0,
+ "XAnnotationElementValue");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleXAnnotationElementValueOrCommaList
+entryRuleXAnnotationElementValueOrCommaList returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListRule()); }
+ iv_ruleXAnnotationElementValueOrCommaList=ruleXAnnotationElementValueOrCommaList
+ { $current=$iv_ruleXAnnotationElementValueOrCommaList.current; }
+ EOF
+;
+
+// Rule XAnnotationElementValueOrCommaList
+ruleXAnnotationElementValueOrCommaList returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((((((
+) '#'
+ '['
+))=>((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralAction_0_0_0_0(),
+ $current);
+ }
+) otherlv_1='#'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getNumberSignKeyword_0_0_0_1());
+ }
+ otherlv_2='['
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getLeftSquareBracketKeyword_0_0_0_2());
+ }
+))((
+(
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0());
+ }
+ lv_elements_3_0=ruleXAnnotationOrExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_3_0,
+ "XAnnotationOrExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_4=','
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_0_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0());
+ }
+ lv_elements_5_0=ruleXAnnotationOrExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_5_0,
+ "XAnnotationOrExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)? otherlv_6=']'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getRightSquareBracketKeyword_0_2());
+ }
+)
+ |(
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXAnnotationOrExpressionParserRuleCall_1_0());
+ }
+ this_XAnnotationOrExpression_7=ruleXAnnotationOrExpression
+ {
+ $current = $this_XAnnotationOrExpression_7.current;
+ afterParserOrEnumRuleCall();
+ }
+((
+ {
+ $current = forceCreateModelElementAndAdd(
+ grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0(),
+ $current);
+ }
+)( otherlv_9=','
+ {
+ newLeafNode(otherlv_9, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_1_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_1_1_1_1_0());
+ }
+ lv_elements_10_0=ruleXAnnotationOrExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_10_0,
+ "XAnnotationOrExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))+)?))
+;
+
+
+
+
+
+// Entry rule entryRuleXAnnotationElementValue
+entryRuleXAnnotationElementValue returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXAnnotationElementValueRule()); }
+ iv_ruleXAnnotationElementValue=ruleXAnnotationElementValue
+ { $current=$iv_ruleXAnnotationElementValue.current; }
+ EOF
+;
+
+// Rule XAnnotationElementValue
+ruleXAnnotationElementValue returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((((((
+) '#'
+ '['
+))=>((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXAnnotationElementValueAccess().getXListLiteralAction_0_0_0_0(),
+ $current);
+ }
+) otherlv_1='#'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXAnnotationElementValueAccess().getNumberSignKeyword_0_0_0_1());
+ }
+ otherlv_2='['
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXAnnotationElementValueAccess().getLeftSquareBracketKeyword_0_0_0_2());
+ }
+))((
+(
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0());
+ }
+ lv_elements_3_0=ruleXAnnotationOrExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationElementValueRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_3_0,
+ "XAnnotationOrExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_4=','
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXAnnotationElementValueAccess().getCommaKeyword_0_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0());
+ }
+ lv_elements_5_0=ruleXAnnotationOrExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAnnotationElementValueRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_5_0,
+ "XAnnotationOrExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)? otherlv_6=']'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXAnnotationElementValueAccess().getRightSquareBracketKeyword_0_2());
+ }
+)
+ |
+ {
+ newCompositeNode(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1());
+ }
+ this_XAnnotationOrExpression_7=ruleXAnnotationOrExpression
+ {
+ $current = $this_XAnnotationOrExpression_7.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleXAnnotationOrExpression
+entryRuleXAnnotationOrExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXAnnotationOrExpressionRule()); }
+ iv_ruleXAnnotationOrExpression=ruleXAnnotationOrExpression
+ { $current=$iv_ruleXAnnotationOrExpression.current; }
+ EOF
+;
+
+// Rule XAnnotationOrExpression
+ruleXAnnotationOrExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0());
+ }
+ this_XAnnotation_0=ruleXAnnotation
+ {
+ $current = $this_XAnnotation_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1());
+ }
+ this_XExpression_1=ruleXExpression
+ {
+ $current = $this_XExpression_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleXExpression
+entryRuleXExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXExpressionRule()); }
+ iv_ruleXExpression=ruleXExpression
+ { $current=$iv_ruleXExpression.current; }
+ EOF
+;
+
+// Rule XExpression
+ruleXExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+
+ {
+ newCompositeNode(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall());
+ }
+ this_XAssignment_0=ruleXAssignment
+ {
+ $current = $this_XAssignment_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+;
+
+
+
+
+
+// Entry rule entryRuleXAssignment
+entryRuleXAssignment returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXAssignmentRule()); }
+ iv_ruleXAssignment=ruleXAssignment
+ { $current=$iv_ruleXAssignment.current; }
+ EOF
+;
+
+// Rule XAssignment
+ruleXAssignment returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0(),
+ $current);
+ }
+)(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXAssignmentRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0());
+ }
+ ruleFeatureCallID {
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ {
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2());
+ }
+ruleOpSingleAssign
+ {
+ afterParserOrEnumRuleCall();
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0());
+ }
+ lv_value_3_0=ruleXAssignment {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAssignmentRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_3_0,
+ "XAssignment");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |(
+ {
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0());
+ }
+ this_XOrExpression_4=ruleXOrExpression
+ {
+ $current = $this_XOrExpression_4.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+ ruleOpMultiAssign
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXAssignmentRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0());
+ }
+ ruleOpMultiAssign {
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0());
+ }
+ lv_rightOperand_7_0=ruleXAssignment {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAssignmentRule());
+ }
+ set(
+ $current,
+ "rightOperand",
+ lv_rightOperand_7_0,
+ "XAssignment");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?))
+;
+
+
+
+
+
+// Entry rule entryRuleOpSingleAssign
+entryRuleOpSingleAssign returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getOpSingleAssignRule()); }
+ iv_ruleOpSingleAssign=ruleOpSingleAssign
+ { $current=$iv_ruleOpSingleAssign.current.getText(); }
+ EOF
+;
+
+// Rule OpSingleAssign
+ruleOpSingleAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+
+ kw='='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword());
+ }
+
+ ;
+
+
+
+
+
+// Entry rule entryRuleOpMultiAssign
+entryRuleOpMultiAssign returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getOpMultiAssignRule()); }
+ iv_ruleOpMultiAssign=ruleOpMultiAssign
+ { $current=$iv_ruleOpMultiAssign.current.getText(); }
+ EOF
+;
+
+// Rule OpMultiAssign
+ruleOpMultiAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ kw='+='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0());
+ }
+
+ |
+ kw='-='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1());
+ }
+
+ |
+ kw='*='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2());
+ }
+
+ |
+ kw='/='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3());
+ }
+
+ |
+ kw='%='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4());
+ }
+
+ |(
+ kw='<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0());
+ }
+
+ kw='<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1());
+ }
+
+ kw='='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2());
+ }
+)
+ |(
+ kw='>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0());
+ }
+(
+ kw='>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1());
+ }
+)?
+ kw='>='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2());
+ }
+))
+ ;
+
+
+
+
+
+// Entry rule entryRuleXOrExpression
+entryRuleXOrExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXOrExpressionRule()); }
+ iv_ruleXOrExpression=ruleXOrExpression
+ { $current=$iv_ruleXOrExpression.current; }
+ EOF
+;
+
+// Rule XOrExpression
+ruleXOrExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0());
+ }
+ this_XAndExpression_0=ruleXAndExpression
+ {
+ $current = $this_XAndExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+ ruleOpOr
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXOrExpressionRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ ruleOpOr {
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0());
+ }
+ lv_rightOperand_3_0=ruleXAndExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXOrExpressionRule());
+ }
+ set(
+ $current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "XAndExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleOpOr
+entryRuleOpOr returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getOpOrRule()); }
+ iv_ruleOpOr=ruleOpOr
+ { $current=$iv_ruleOpOr.current.getText(); }
+ EOF
+;
+
+// Rule OpOr
+ruleOpOr returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+
+ kw='||'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword());
+ }
+
+ ;
+
+
+
+
+
+// Entry rule entryRuleXAndExpression
+entryRuleXAndExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXAndExpressionRule()); }
+ iv_ruleXAndExpression=ruleXAndExpression
+ { $current=$iv_ruleXAndExpression.current; }
+ EOF
+;
+
+// Rule XAndExpression
+ruleXAndExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0());
+ }
+ this_XEqualityExpression_0=ruleXEqualityExpression
+ {
+ $current = $this_XEqualityExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+ ruleOpAnd
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXAndExpressionRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ ruleOpAnd {
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0());
+ }
+ lv_rightOperand_3_0=ruleXEqualityExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAndExpressionRule());
+ }
+ set(
+ $current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "XEqualityExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleOpAnd
+entryRuleOpAnd returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getOpAndRule()); }
+ iv_ruleOpAnd=ruleOpAnd
+ { $current=$iv_ruleOpAnd.current.getText(); }
+ EOF
+;
+
+// Rule OpAnd
+ruleOpAnd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+
+ kw='&&'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword());
+ }
+
+ ;
+
+
+
+
+
+// Entry rule entryRuleXEqualityExpression
+entryRuleXEqualityExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXEqualityExpressionRule()); }
+ iv_ruleXEqualityExpression=ruleXEqualityExpression
+ { $current=$iv_ruleXEqualityExpression.current; }
+ EOF
+;
+
+// Rule XEqualityExpression
+ruleXEqualityExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0());
+ }
+ this_XRelationalExpression_0=ruleXRelationalExpression
+ {
+ $current = $this_XRelationalExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+ ruleOpEquality
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXEqualityExpressionRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ ruleOpEquality {
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0());
+ }
+ lv_rightOperand_3_0=ruleXRelationalExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXEqualityExpressionRule());
+ }
+ set(
+ $current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "XRelationalExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleOpEquality
+entryRuleOpEquality returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getOpEqualityRule()); }
+ iv_ruleOpEquality=ruleOpEquality
+ { $current=$iv_ruleOpEquality.current.getText(); }
+ EOF
+;
+
+// Rule OpEquality
+ruleOpEquality returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ kw='=='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0());
+ }
+
+ |
+ kw='!='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1());
+ }
+
+ |
+ kw='==='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2());
+ }
+
+ |
+ kw='!=='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3());
+ }
+)
+ ;
+
+
+
+
+
+// Entry rule entryRuleXRelationalExpression
+entryRuleXRelationalExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXRelationalExpressionRule()); }
+ iv_ruleXRelationalExpression=ruleXRelationalExpression
+ { $current=$iv_ruleXRelationalExpression.current; }
+ EOF
+;
+
+// Rule XRelationalExpression
+ruleXRelationalExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0());
+ }
+ this_XOtherOperatorExpression_0=ruleXOtherOperatorExpression
+ {
+ $current = $this_XOtherOperatorExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+((((((
+) 'instanceof'
+))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0(),
+ $current);
+ }
+) otherlv_2='instanceof'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1());
+ }
+))(
+(
+ {
+ newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0());
+ }
+ lv_type_3_0=ruleJvmTypeReference {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule());
+ }
+ set(
+ $current,
+ "type",
+ lv_type_3_0,
+ "JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |(((((
+)(
+(
+ ruleOpCompare
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXRelationalExpressionRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0());
+ }
+ ruleOpCompare {
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0());
+ }
+ lv_rightOperand_6_0=ruleXOtherOperatorExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule());
+ }
+ set(
+ $current,
+ "rightOperand",
+ lv_rightOperand_6_0,
+ "XOtherOperatorExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))*)
+;
+
+
+
+
+
+// Entry rule entryRuleOpCompare
+entryRuleOpCompare returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getOpCompareRule()); }
+ iv_ruleOpCompare=ruleOpCompare
+ { $current=$iv_ruleOpCompare.current.getText(); }
+ EOF
+;
+
+// Rule OpCompare
+ruleOpCompare returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ kw='>='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0());
+ }
+
+ |(
+ kw='<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0());
+ }
+
+ kw='='
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1());
+ }
+)
+ |
+ kw='>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2());
+ }
+
+ |
+ kw='<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3());
+ }
+)
+ ;
+
+
+
+
+
+// Entry rule entryRuleXOtherOperatorExpression
+entryRuleXOtherOperatorExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXOtherOperatorExpressionRule()); }
+ iv_ruleXOtherOperatorExpression=ruleXOtherOperatorExpression
+ { $current=$iv_ruleXOtherOperatorExpression.current; }
+ EOF
+;
+
+// Rule XOtherOperatorExpression
+ruleXOtherOperatorExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0());
+ }
+ this_XAdditiveExpression_0=ruleXAdditiveExpression
+ {
+ $current = $this_XAdditiveExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+ ruleOpOther
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXOtherOperatorExpressionRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ ruleOpOther {
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0());
+ }
+ lv_rightOperand_3_0=ruleXAdditiveExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXOtherOperatorExpressionRule());
+ }
+ set(
+ $current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "XAdditiveExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleOpOther
+entryRuleOpOther returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getOpOtherRule()); }
+ iv_ruleOpOther=ruleOpOther
+ { $current=$iv_ruleOpOther.current.getText(); }
+ EOF
+;
+
+// Rule OpOther
+ruleOpOther returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ kw='->'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0());
+ }
+
+ |
+ kw='..<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1());
+ }
+
+ |(
+ kw='>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0());
+ }
+
+ kw='..'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1());
+ }
+)
+ |
+ kw='..'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3());
+ }
+
+ |
+ kw='=>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4());
+ }
+
+ |(
+ kw='>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0());
+ }
+((((
+ '>'
+
+ '>'
+))=>(
+ kw='>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0());
+ }
+
+ kw='>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1());
+ }
+))
+ |
+ kw='>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1());
+ }
+))
+ |(
+ kw='<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0());
+ }
+((((
+ '<'
+
+ '<'
+))=>(
+ kw='<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0());
+ }
+
+ kw='<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1());
+ }
+))
+ |
+ kw='<'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1());
+ }
+
+ |
+ kw='=>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2());
+ }
+))
+ |
+ kw='<>'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7());
+ }
+
+ |
+ kw='?:'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8());
+ }
+)
+ ;
+
+
+
+
+
+// Entry rule entryRuleXAdditiveExpression
+entryRuleXAdditiveExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXAdditiveExpressionRule()); }
+ iv_ruleXAdditiveExpression=ruleXAdditiveExpression
+ { $current=$iv_ruleXAdditiveExpression.current; }
+ EOF
+;
+
+// Rule XAdditiveExpression
+ruleXAdditiveExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0());
+ }
+ this_XMultiplicativeExpression_0=ruleXMultiplicativeExpression
+ {
+ $current = $this_XMultiplicativeExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+ ruleOpAdd
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXAdditiveExpressionRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ ruleOpAdd {
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0());
+ }
+ lv_rightOperand_3_0=ruleXMultiplicativeExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXAdditiveExpressionRule());
+ }
+ set(
+ $current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "XMultiplicativeExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleOpAdd
+entryRuleOpAdd returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getOpAddRule()); }
+ iv_ruleOpAdd=ruleOpAdd
+ { $current=$iv_ruleOpAdd.current.getText(); }
+ EOF
+;
+
+// Rule OpAdd
+ruleOpAdd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ kw='+'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpAddAccess().getPlusSignKeyword_0());
+ }
+
+ |
+ kw='-'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1());
+ }
+)
+ ;
+
+
+
+
+
+// Entry rule entryRuleXMultiplicativeExpression
+entryRuleXMultiplicativeExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXMultiplicativeExpressionRule()); }
+ iv_ruleXMultiplicativeExpression=ruleXMultiplicativeExpression
+ { $current=$iv_ruleXMultiplicativeExpression.current; }
+ EOF
+;
+
+// Rule XMultiplicativeExpression
+ruleXMultiplicativeExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0());
+ }
+ this_XUnaryOperation_0=ruleXUnaryOperation
+ {
+ $current = $this_XUnaryOperation_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+ ruleOpMulti
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXMultiplicativeExpressionRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+ }
+ ruleOpMulti {
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0());
+ }
+ lv_rightOperand_3_0=ruleXUnaryOperation {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXMultiplicativeExpressionRule());
+ }
+ set(
+ $current,
+ "rightOperand",
+ lv_rightOperand_3_0,
+ "XUnaryOperation");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleOpMulti
+entryRuleOpMulti returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getOpMultiRule()); }
+ iv_ruleOpMulti=ruleOpMulti
+ { $current=$iv_ruleOpMulti.current.getText(); }
+ EOF
+;
+
+// Rule OpMulti
+ruleOpMulti returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ kw='*'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskKeyword_0());
+ }
+
+ |
+ kw='**'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1());
+ }
+
+ |
+ kw='/'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAccess().getSolidusKeyword_2());
+ }
+
+ |
+ kw='%'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpMultiAccess().getPercentSignKeyword_3());
+ }
+)
+ ;
+
+
+
+
+
+// Entry rule entryRuleXUnaryOperation
+entryRuleXUnaryOperation returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXUnaryOperationRule()); }
+ iv_ruleXUnaryOperation=ruleXUnaryOperation
+ { $current=$iv_ruleXUnaryOperation.current; }
+ EOF
+;
+
+// Rule XUnaryOperation
+ruleXUnaryOperation returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0(),
+ $current);
+ }
+)(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXUnaryOperationRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0());
+ }
+ ruleOpUnary {
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0());
+ }
+ lv_operand_2_0=ruleXUnaryOperation {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXUnaryOperationRule());
+ }
+ set(
+ $current,
+ "operand",
+ lv_operand_2_0,
+ "XUnaryOperation");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |
+ {
+ newCompositeNode(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1());
+ }
+ this_XCastedExpression_3=ruleXCastedExpression
+ {
+ $current = $this_XCastedExpression_3.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleOpUnary
+entryRuleOpUnary returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getOpUnaryRule()); }
+ iv_ruleOpUnary=ruleOpUnary
+ { $current=$iv_ruleOpUnary.current.getText(); }
+ EOF
+;
+
+// Rule OpUnary
+ruleOpUnary returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ kw='!'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0());
+ }
+
+ |
+ kw='-'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1());
+ }
+
+ |
+ kw='+'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2());
+ }
+)
+ ;
+
+
+
+
+
+// Entry rule entryRuleXCastedExpression
+entryRuleXCastedExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXCastedExpressionRule()); }
+ iv_ruleXCastedExpression=ruleXCastedExpression
+ { $current=$iv_ruleXCastedExpression.current; }
+ EOF
+;
+
+// Rule XCastedExpression
+ruleXCastedExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0());
+ }
+ this_XPostfixOperation_0=ruleXPostfixOperation
+ {
+ $current = $this_XPostfixOperation_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+) 'as'
+))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0(),
+ $current);
+ }
+) otherlv_2='as'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1());
+ }
+))(
+(
+ {
+ newCompositeNode(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0());
+ }
+ lv_type_3_0=ruleJvmTypeReference {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXCastedExpressionRule());
+ }
+ set(
+ $current,
+ "type",
+ lv_type_3_0,
+ "JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleXPostfixOperation
+entryRuleXPostfixOperation returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXPostfixOperationRule()); }
+ iv_ruleXPostfixOperation=ruleXPostfixOperation
+ { $current=$iv_ruleXPostfixOperation.current; }
+ EOF
+;
+
+// Rule XPostfixOperation
+ruleXPostfixOperation returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0());
+ }
+ this_XMemberFeatureCall_0=ruleXMemberFeatureCall
+ {
+ $current = $this_XMemberFeatureCall_0.current;
+ afterParserOrEnumRuleCall();
+ }
+((((
+)(
+(
+ ruleOpPostfix
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0(),
+ $current);
+ }
+)(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXPostfixOperationRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0());
+ }
+ ruleOpPostfix {
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))?)
+;
+
+
+
+
+
+// Entry rule entryRuleOpPostfix
+entryRuleOpPostfix returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getOpPostfixRule()); }
+ iv_ruleOpPostfix=ruleOpPostfix
+ { $current=$iv_ruleOpPostfix.current.getText(); }
+ EOF
+;
+
+// Rule OpPostfix
+ruleOpPostfix returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ kw='++'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0());
+ }
+
+ |
+ kw='--'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1());
+ }
+)
+ ;
+
+
+
+
+
+// Entry rule entryRuleXMemberFeatureCall
+entryRuleXMemberFeatureCall returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXMemberFeatureCallRule()); }
+ iv_ruleXMemberFeatureCall=ruleXMemberFeatureCall
+ { $current=$iv_ruleXMemberFeatureCall.current; }
+ EOF
+;
+
+// Rule XMemberFeatureCall
+ruleXMemberFeatureCall returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0());
+ }
+ this_XPrimaryExpression_0=ruleXPrimaryExpression
+ {
+ $current = $this_XPrimaryExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+((((((
+)( '.'
+
+ |(
+(
+ '::'
+
+
+)
+))(
+(
+ ruleFeatureCallID
+)
+) ruleOpSingleAssign))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0(),
+ $current);
+ }
+)( otherlv_2='.'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0());
+ }
+
+ |(
+(
+ lv_explicitStatic_3_0= '::'
+ {
+ newLeafNode(lv_explicitStatic_3_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+ setWithLastConsumed($current, "explicitStatic", true, "::");
+ }
+
+)
+))(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0());
+ }
+ ruleFeatureCallID {
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3());
+ }
+ruleOpSingleAssign
+ {
+ afterParserOrEnumRuleCall();
+ }
+))(
+(
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0());
+ }
+ lv_value_6_0=ruleXAssignment {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_6_0,
+ "XAssignment");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |(((((
+)( '.'
+
+ |(
+(
+ '?.'
+
+
+)
+)
+ |(
+(
+ '::'
+
+
+)
+))))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0(),
+ $current);
+ }
+)( otherlv_8='.'
+ {
+ newLeafNode(otherlv_8, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0());
+ }
+
+ |(
+(
+ lv_nullSafe_9_0= '?.'
+ {
+ newLeafNode(lv_nullSafe_9_0, grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+ setWithLastConsumed($current, "nullSafe", true, "?.");
+ }
+
+)
+)
+ |(
+(
+ lv_explicitStatic_10_0= '::'
+ {
+ newLeafNode(lv_explicitStatic_10_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+ setWithLastConsumed($current, "explicitStatic", true, "::");
+ }
+
+)
+))))( otherlv_11='<'
+ {
+ newLeafNode(otherlv_11, grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0());
+ }
+ lv_typeArguments_12_0=ruleJvmArgumentTypeReference {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ $current,
+ "typeArguments",
+ lv_typeArguments_12_0,
+ "JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_13=','
+ {
+ newLeafNode(otherlv_13, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0());
+ }
+ lv_typeArguments_14_0=ruleJvmArgumentTypeReference {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ $current,
+ "typeArguments",
+ lv_typeArguments_14_0,
+ "JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))* otherlv_15='>'
+ {
+ newLeafNode(otherlv_15, grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3());
+ }
+)?(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0());
+ }
+ ruleIdOrSuper {
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(((
+(
+ '('
+
+
+)
+)=>
+(
+ lv_explicitOperationCall_17_0= '('
+ {
+ newLeafNode(lv_explicitOperationCall_17_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+ }
+ setWithLastConsumed($current, "explicitOperationCall", true, "(");
+ }
+
+)
+)(((((
+)((
+(
+ruleJvmFormalParameter
+)
+)( ','
+(
+(
+ruleJvmFormalParameter
+)
+))*)?(
+(
+ '|'
+
+
+)
+)))=>
+(
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0());
+ }
+ lv_memberCallArguments_18_0=ruleXShortClosure {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ $current,
+ "memberCallArguments",
+ lv_memberCallArguments_18_0,
+ "XShortClosure");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |((
+(
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0());
+ }
+ lv_memberCallArguments_19_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ $current,
+ "memberCallArguments",
+ lv_memberCallArguments_19_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_20=','
+ {
+ newLeafNode(otherlv_20, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0());
+ }
+ lv_memberCallArguments_21_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ $current,
+ "memberCallArguments",
+ lv_memberCallArguments_21_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*))? otherlv_22=')'
+ {
+ newLeafNode(otherlv_22, grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2());
+ }
+)?((((
+) '['
+))=>
+(
+ {
+ newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0());
+ }
+ lv_memberCallArguments_23_0=ruleXClosure {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+ }
+ add(
+ $current,
+ "memberCallArguments",
+ lv_memberCallArguments_23_0,
+ "XClosure");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?))*)
+;
+
+
+
+
+
+// Entry rule entryRuleXPrimaryExpression
+entryRuleXPrimaryExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXPrimaryExpressionRule()); }
+ iv_ruleXPrimaryExpression=ruleXPrimaryExpression
+ { $current=$iv_ruleXPrimaryExpression.current; }
+ EOF
+;
+
+// Rule XPrimaryExpression
+ruleXPrimaryExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0());
+ }
+ this_XConstructorCall_0=ruleXConstructorCall
+ {
+ $current = $this_XConstructorCall_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1());
+ }
+ this_XBlockExpression_1=ruleXBlockExpression
+ {
+ $current = $this_XBlockExpression_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2());
+ }
+ this_XSwitchExpression_2=ruleXSwitchExpression
+ {
+ $current = $this_XSwitchExpression_2.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |((((
+) 'synchronized'
+ '('
+))=>
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3());
+ }
+ this_XSynchronizedExpression_3=ruleXSynchronizedExpression
+ {
+ $current = $this_XSynchronizedExpression_3.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4());
+ }
+ this_XFeatureCall_4=ruleXFeatureCall
+ {
+ $current = $this_XFeatureCall_4.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5());
+ }
+ this_XLiteral_5=ruleXLiteral
+ {
+ $current = $this_XLiteral_5.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6());
+ }
+ this_XIfExpression_6=ruleXIfExpression
+ {
+ $current = $this_XIfExpression_6.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |((((
+) 'for'
+ '('
+(
+(
+ruleJvmFormalParameter
+)
+) ':'
+))=>
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7());
+ }
+ this_XForLoopExpression_7=ruleXForLoopExpression
+ {
+ $current = $this_XForLoopExpression_7.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8());
+ }
+ this_XBasicForLoopExpression_8=ruleXBasicForLoopExpression
+ {
+ $current = $this_XBasicForLoopExpression_8.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9());
+ }
+ this_XWhileExpression_9=ruleXWhileExpression
+ {
+ $current = $this_XWhileExpression_9.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10());
+ }
+ this_XDoWhileExpression_10=ruleXDoWhileExpression
+ {
+ $current = $this_XDoWhileExpression_10.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11());
+ }
+ this_XThrowExpression_11=ruleXThrowExpression
+ {
+ $current = $this_XThrowExpression_11.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12());
+ }
+ this_XReturnExpression_12=ruleXReturnExpression
+ {
+ $current = $this_XReturnExpression_12.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13());
+ }
+ this_XTryCatchFinallyExpression_13=ruleXTryCatchFinallyExpression
+ {
+ $current = $this_XTryCatchFinallyExpression_13.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14());
+ }
+ this_XParenthesizedExpression_14=ruleXParenthesizedExpression
+ {
+ $current = $this_XParenthesizedExpression_14.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleXLiteral
+entryRuleXLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXLiteralRule()); }
+ iv_ruleXLiteral=ruleXLiteral
+ { $current=$iv_ruleXLiteral.current; }
+ EOF
+;
+
+// Rule XLiteral
+ruleXLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0());
+ }
+ this_XCollectionLiteral_0=ruleXCollectionLiteral
+ {
+ $current = $this_XCollectionLiteral_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |((((
+) '['
+))=>
+ {
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1());
+ }
+ this_XClosure_1=ruleXClosure
+ {
+ $current = $this_XClosure_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |
+ {
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2());
+ }
+ this_XBooleanLiteral_2=ruleXBooleanLiteral
+ {
+ $current = $this_XBooleanLiteral_2.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3());
+ }
+ this_XNumberLiteral_3=ruleXNumberLiteral
+ {
+ $current = $this_XNumberLiteral_3.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4());
+ }
+ this_XNullLiteral_4=ruleXNullLiteral
+ {
+ $current = $this_XNullLiteral_4.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5());
+ }
+ this_XStringLiteral_5=ruleXStringLiteral
+ {
+ $current = $this_XStringLiteral_5.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6());
+ }
+ this_XTypeLiteral_6=ruleXTypeLiteral
+ {
+ $current = $this_XTypeLiteral_6.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleXCollectionLiteral
+entryRuleXCollectionLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXCollectionLiteralRule()); }
+ iv_ruleXCollectionLiteral=ruleXCollectionLiteral
+ { $current=$iv_ruleXCollectionLiteral.current; }
+ EOF
+;
+
+// Rule XCollectionLiteral
+ruleXCollectionLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0());
+ }
+ this_XSetLiteral_0=ruleXSetLiteral
+ {
+ $current = $this_XSetLiteral_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1());
+ }
+ this_XListLiteral_1=ruleXListLiteral
+ {
+ $current = $this_XListLiteral_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleXSetLiteral
+entryRuleXSetLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXSetLiteralRule()); }
+ iv_ruleXSetLiteral=ruleXSetLiteral
+ { $current=$iv_ruleXSetLiteral.current; }
+ EOF
+;
+
+// Rule XSetLiteral
+ruleXSetLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0(),
+ $current);
+ }
+) otherlv_1='#'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1());
+ }
+ otherlv_2='{'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2());
+ }
+((
+(
+ {
+ newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0());
+ }
+ lv_elements_3_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSetLiteralRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_3_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_4=','
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0());
+ }
+ lv_elements_5_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSetLiteralRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_5_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)? otherlv_6='}'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleXListLiteral
+entryRuleXListLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXListLiteralRule()); }
+ iv_ruleXListLiteral=ruleXListLiteral
+ { $current=$iv_ruleXListLiteral.current; }
+ EOF
+;
+
+// Rule XListLiteral
+ruleXListLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXListLiteralAccess().getXListLiteralAction_0(),
+ $current);
+ }
+) otherlv_1='#'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1());
+ }
+ otherlv_2='['
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2());
+ }
+((
+(
+ {
+ newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0());
+ }
+ lv_elements_3_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXListLiteralRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_3_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_4=','
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0());
+ }
+ lv_elements_5_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXListLiteralRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_5_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)? otherlv_6=']'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleXClosure
+entryRuleXClosure returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXClosureRule()); }
+ iv_ruleXClosure=ruleXClosure
+ { $current=$iv_ruleXClosure.current; }
+ EOF
+;
+
+// Rule XClosure
+ruleXClosure returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((((
+) '['
+))=>((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXClosureAccess().getXClosureAction_0_0_0(),
+ $current);
+ }
+) otherlv_1='['
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1());
+ }
+))(((((
+(
+ruleJvmFormalParameter
+)
+)( ','
+(
+(
+ruleJvmFormalParameter
+)
+))*)?(
+(
+ '|'
+
+
+)
+)))=>(((
+(
+ {
+ newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0());
+ }
+ lv_declaredFormalParameters_2_0=ruleJvmFormalParameter {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXClosureRule());
+ }
+ add(
+ $current,
+ "declaredFormalParameters",
+ lv_declaredFormalParameters_2_0,
+ "JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_3=','
+ {
+ newLeafNode(otherlv_3, grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0());
+ }
+ lv_declaredFormalParameters_4_0=ruleJvmFormalParameter {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXClosureRule());
+ }
+ add(
+ $current,
+ "declaredFormalParameters",
+ lv_declaredFormalParameters_4_0,
+ "JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)?(
+(
+ lv_explicitSyntax_5_0= '|'
+ {
+ newLeafNode(lv_explicitSyntax_5_0, grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXClosureRule());
+ }
+ setWithLastConsumed($current, "explicitSyntax", true, "|");
+ }
+
+)
+)))?(
+(
+ {
+ newCompositeNode(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0());
+ }
+ lv_expression_6_0=ruleXExpressionInClosure {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXClosureRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_6_0,
+ "XExpressionInClosure");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_7=']'
+ {
+ newLeafNode(otherlv_7, grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleXExpressionInClosure
+entryRuleXExpressionInClosure returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXExpressionInClosureRule()); }
+ iv_ruleXExpressionInClosure=ruleXExpressionInClosure
+ { $current=$iv_ruleXExpressionInClosure.current; }
+ EOF
+;
+
+// Rule XExpressionInClosure
+ruleXExpressionInClosure returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0(),
+ $current);
+ }
+)((
+(
+ {
+ newCompositeNode(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0());
+ }
+ lv_expressions_1_0=ruleXExpressionOrVarDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXExpressionInClosureRule());
+ }
+ add(
+ $current,
+ "expressions",
+ lv_expressions_1_0,
+ "XExpressionOrVarDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_2=';'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1());
+ }
+)?)*)
+;
+
+
+
+
+
+// Entry rule entryRuleXShortClosure
+entryRuleXShortClosure returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXShortClosureRule()); }
+ iv_ruleXShortClosure=ruleXShortClosure
+ { $current=$iv_ruleXShortClosure.current; }
+ EOF
+;
+
+// Rule XShortClosure
+ruleXShortClosure returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((((
+)((
+(
+ruleJvmFormalParameter
+)
+)( ','
+(
+(
+ruleJvmFormalParameter
+)
+))*)?(
+(
+ '|'
+
+
+)
+)))=>((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0(),
+ $current);
+ }
+)((
+(
+ {
+ newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0());
+ }
+ lv_declaredFormalParameters_1_0=ruleJvmFormalParameter {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXShortClosureRule());
+ }
+ add(
+ $current,
+ "declaredFormalParameters",
+ lv_declaredFormalParameters_1_0,
+ "JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_2=','
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0());
+ }
+ lv_declaredFormalParameters_3_0=ruleJvmFormalParameter {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXShortClosureRule());
+ }
+ add(
+ $current,
+ "declaredFormalParameters",
+ lv_declaredFormalParameters_3_0,
+ "JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)?(
+(
+ lv_explicitSyntax_4_0= '|'
+ {
+ newLeafNode(lv_explicitSyntax_4_0, grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXShortClosureRule());
+ }
+ setWithLastConsumed($current, "explicitSyntax", true, "|");
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0());
+ }
+ lv_expression_5_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXShortClosureRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_5_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleXParenthesizedExpression
+entryRuleXParenthesizedExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXParenthesizedExpressionRule()); }
+ iv_ruleXParenthesizedExpression=ruleXParenthesizedExpression
+ { $current=$iv_ruleXParenthesizedExpression.current; }
+ EOF
+;
+
+// Rule XParenthesizedExpression
+ruleXParenthesizedExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='('
+ {
+ newLeafNode(otherlv_0, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0());
+ }
+
+ {
+ newCompositeNode(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1());
+ }
+ this_XExpression_1=ruleXExpression
+ {
+ $current = $this_XExpression_1.current;
+ afterParserOrEnumRuleCall();
+ }
+ otherlv_2=')'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleXIfExpression
+entryRuleXIfExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXIfExpressionRule()); }
+ iv_ruleXIfExpression=ruleXIfExpression
+ { $current=$iv_ruleXIfExpression.current; }
+ EOF
+;
+
+// Rule XIfExpression
+ruleXIfExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0(),
+ $current);
+ }
+) otherlv_1='if'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXIfExpressionAccess().getIfKeyword_1());
+ }
+ otherlv_2='('
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0());
+ }
+ lv_if_3_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXIfExpressionRule());
+ }
+ set(
+ $current,
+ "if",
+ lv_if_3_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_4=')'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0());
+ }
+ lv_then_5_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXIfExpressionRule());
+ }
+ set(
+ $current,
+ "then",
+ lv_then_5_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((( 'else'
+)=> otherlv_6='else'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0());
+ }
+ lv_else_7_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXIfExpressionRule());
+ }
+ set(
+ $current,
+ "else",
+ lv_else_7_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleXSwitchExpression
+entryRuleXSwitchExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXSwitchExpressionRule()); }
+ iv_ruleXSwitchExpression=ruleXSwitchExpression
+ { $current=$iv_ruleXSwitchExpression.current; }
+ EOF
+;
+
+// Rule XSwitchExpression
+ruleXSwitchExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0(),
+ $current);
+ }
+) otherlv_1='switch'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1());
+ }
+((((( '('
+(
+(
+ruleJvmFormalParameter
+)
+) ':'
+))=>( otherlv_2='('
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0());
+ }
+ lv_declaredParam_3_0=ruleJvmFormalParameter {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ set(
+ $current,
+ "declaredParam",
+ lv_declaredParam_3_0,
+ "JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_4=':'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2());
+ }
+))(
+(
+ {
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0());
+ }
+ lv_switch_5_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ set(
+ $current,
+ "switch",
+ lv_switch_5_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_6=')'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2());
+ }
+)
+ |(((((
+(
+ruleJvmFormalParameter
+)
+) ':'
+))=>((
+(
+ {
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0());
+ }
+ lv_declaredParam_7_0=ruleJvmFormalParameter {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ set(
+ $current,
+ "declaredParam",
+ lv_declaredParam_7_0,
+ "JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_8=':'
+ {
+ newLeafNode(otherlv_8, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1());
+ }
+))?(
+(
+ {
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0());
+ }
+ lv_switch_9_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ set(
+ $current,
+ "switch",
+ lv_switch_9_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))) otherlv_10='{'
+ {
+ newLeafNode(otherlv_10, grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0());
+ }
+ lv_cases_11_0=ruleXCasePart {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ add(
+ $current,
+ "cases",
+ lv_cases_11_0,
+ "XCasePart");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)*( otherlv_12='default'
+ {
+ newLeafNode(otherlv_12, grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0());
+ }
+ otherlv_13=':'
+ {
+ newLeafNode(otherlv_13, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0());
+ }
+ lv_default_14_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+ }
+ set(
+ $current,
+ "default",
+ lv_default_14_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))? otherlv_15='}'
+ {
+ newLeafNode(otherlv_15, grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleXCasePart
+entryRuleXCasePart returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXCasePartRule()); }
+ iv_ruleXCasePart=ruleXCasePart
+ { $current=$iv_ruleXCasePart.current; }
+ EOF
+;
+
+// Rule XCasePart
+ruleXCasePart returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXCasePartAccess().getXCasePartAction_0(),
+ $current);
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0());
+ }
+ lv_typeGuard_1_0=ruleJvmTypeReference {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXCasePartRule());
+ }
+ set(
+ $current,
+ "typeGuard",
+ lv_typeGuard_1_0,
+ "JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?( otherlv_2='case'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXCasePartAccess().getCaseKeyword_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0());
+ }
+ lv_case_3_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXCasePartRule());
+ }
+ set(
+ $current,
+ "case",
+ lv_case_3_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?(( otherlv_4=':'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0());
+ }
+ lv_then_5_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXCasePartRule());
+ }
+ set(
+ $current,
+ "then",
+ lv_then_5_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |(
+(
+ lv_fallThrough_6_0= ','
+ {
+ newLeafNode(lv_fallThrough_6_0, grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXCasePartRule());
+ }
+ setWithLastConsumed($current, "fallThrough", true, ",");
+ }
+
+)
+)))
+;
+
+
+
+
+
+// Entry rule entryRuleXForLoopExpression
+entryRuleXForLoopExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXForLoopExpressionRule()); }
+ iv_ruleXForLoopExpression=ruleXForLoopExpression
+ { $current=$iv_ruleXForLoopExpression.current; }
+ EOF
+;
+
+// Rule XForLoopExpression
+ruleXForLoopExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((((
+) 'for'
+ '('
+(
+(
+ruleJvmFormalParameter
+)
+) ':'
+))=>((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0(),
+ $current);
+ }
+) otherlv_1='for'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1());
+ }
+ otherlv_2='('
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0());
+ }
+ lv_declaredParam_3_0=ruleJvmFormalParameter {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule());
+ }
+ set(
+ $current,
+ "declaredParam",
+ lv_declaredParam_3_0,
+ "JvmFormalParameter");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_4=':'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4());
+ }
+))(
+(
+ {
+ newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0());
+ }
+ lv_forExpression_5_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule());
+ }
+ set(
+ $current,
+ "forExpression",
+ lv_forExpression_5_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_6=')'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0());
+ }
+ lv_eachExpression_7_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule());
+ }
+ set(
+ $current,
+ "eachExpression",
+ lv_eachExpression_7_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleXBasicForLoopExpression
+entryRuleXBasicForLoopExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXBasicForLoopExpressionRule()); }
+ iv_ruleXBasicForLoopExpression=ruleXBasicForLoopExpression
+ { $current=$iv_ruleXBasicForLoopExpression.current; }
+ EOF
+;
+
+// Rule XBasicForLoopExpression
+ruleXBasicForLoopExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0(),
+ $current);
+ }
+) otherlv_1='for'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1());
+ }
+ otherlv_2='('
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2());
+ }
+((
+(
+ {
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0());
+ }
+ lv_initExpressions_3_0=ruleXExpressionOrVarDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ add(
+ $current,
+ "initExpressions",
+ lv_initExpressions_3_0,
+ "XExpressionOrVarDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_4=','
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0());
+ }
+ lv_initExpressions_5_0=ruleXExpressionOrVarDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ add(
+ $current,
+ "initExpressions",
+ lv_initExpressions_5_0,
+ "XExpressionOrVarDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)? otherlv_6=';'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0());
+ }
+ lv_expression_7_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_7_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)? otherlv_8=';'
+ {
+ newLeafNode(otherlv_8, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6());
+ }
+((
+(
+ {
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0());
+ }
+ lv_updateExpressions_9_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ add(
+ $current,
+ "updateExpressions",
+ lv_updateExpressions_9_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_10=','
+ {
+ newLeafNode(otherlv_10, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0());
+ }
+ lv_updateExpressions_11_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ add(
+ $current,
+ "updateExpressions",
+ lv_updateExpressions_11_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)? otherlv_12=')'
+ {
+ newLeafNode(otherlv_12, grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0());
+ }
+ lv_eachExpression_13_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+ }
+ set(
+ $current,
+ "eachExpression",
+ lv_eachExpression_13_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleXWhileExpression
+entryRuleXWhileExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXWhileExpressionRule()); }
+ iv_ruleXWhileExpression=ruleXWhileExpression
+ { $current=$iv_ruleXWhileExpression.current; }
+ EOF
+;
+
+// Rule XWhileExpression
+ruleXWhileExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0(),
+ $current);
+ }
+) otherlv_1='while'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1());
+ }
+ otherlv_2='('
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0());
+ }
+ lv_predicate_3_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXWhileExpressionRule());
+ }
+ set(
+ $current,
+ "predicate",
+ lv_predicate_3_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_4=')'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0());
+ }
+ lv_body_5_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXWhileExpressionRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_5_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleXDoWhileExpression
+entryRuleXDoWhileExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXDoWhileExpressionRule()); }
+ iv_ruleXDoWhileExpression=ruleXDoWhileExpression
+ { $current=$iv_ruleXDoWhileExpression.current; }
+ EOF
+;
+
+// Rule XDoWhileExpression
+ruleXDoWhileExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0(),
+ $current);
+ }
+) otherlv_1='do'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0());
+ }
+ lv_body_2_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_2_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_3='while'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3());
+ }
+ otherlv_4='('
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0());
+ }
+ lv_predicate_5_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule());
+ }
+ set(
+ $current,
+ "predicate",
+ lv_predicate_5_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_6=')'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleXBlockExpression
+entryRuleXBlockExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXBlockExpressionRule()); }
+ iv_ruleXBlockExpression=ruleXBlockExpression
+ { $current=$iv_ruleXBlockExpression.current; }
+ EOF
+;
+
+// Rule XBlockExpression
+ruleXBlockExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0(),
+ $current);
+ }
+) otherlv_1='{'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1());
+ }
+((
+(
+ {
+ newCompositeNode(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0());
+ }
+ lv_expressions_2_0=ruleXExpressionOrVarDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXBlockExpressionRule());
+ }
+ add(
+ $current,
+ "expressions",
+ lv_expressions_2_0,
+ "XExpressionOrVarDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_3=';'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1());
+ }
+)?)* otherlv_4='}'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleXExpressionOrVarDeclaration
+entryRuleXExpressionOrVarDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationRule()); }
+ iv_ruleXExpressionOrVarDeclaration=ruleXExpressionOrVarDeclaration
+ { $current=$iv_ruleXExpressionOrVarDeclaration.current; }
+ EOF
+;
+
+// Rule XExpressionOrVarDeclaration
+ruleXExpressionOrVarDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0());
+ }
+ this_XVariableDeclaration_0=ruleXVariableDeclaration
+ {
+ $current = $this_XVariableDeclaration_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1());
+ }
+ this_XExpression_1=ruleXExpression
+ {
+ $current = $this_XExpression_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleXVariableDeclaration
+entryRuleXVariableDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXVariableDeclarationRule()); }
+ iv_ruleXVariableDeclaration=ruleXVariableDeclaration
+ { $current=$iv_ruleXVariableDeclaration.current; }
+ EOF
+;
+
+// Rule XVariableDeclaration
+ruleXVariableDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0(),
+ $current);
+ }
+)((
+(
+ lv_writeable_1_0= 'var'
+ {
+ newLeafNode(lv_writeable_1_0, grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXVariableDeclarationRule());
+ }
+ setWithLastConsumed($current, "writeable", true, "var");
+ }
+
+)
+)
+ | otherlv_2='val'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1());
+ }
+)(((((
+(
+ruleJvmTypeReference
+)
+)(
+(
+ruleValidID
+)
+)))=>((
+(
+ {
+ newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0());
+ }
+ lv_type_3_0=ruleJvmTypeReference {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+ }
+ set(
+ $current,
+ "type",
+ lv_type_3_0,
+ "JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0());
+ }
+ lv_name_4_0=ruleValidID {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_4_0,
+ "ValidID");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0());
+ }
+ lv_name_5_0=ruleValidID {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_5_0,
+ "ValidID");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))( otherlv_6='='
+ {
+ newLeafNode(otherlv_6, grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0());
+ }
+ lv_right_7_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+ }
+ set(
+ $current,
+ "right",
+ lv_right_7_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleJvmFormalParameter
+entryRuleJvmFormalParameter returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getJvmFormalParameterRule()); }
+ iv_ruleJvmFormalParameter=ruleJvmFormalParameter
+ { $current=$iv_ruleJvmFormalParameter.current; }
+ EOF
+;
+
+// Rule JvmFormalParameter
+ruleJvmFormalParameter returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0());
+ }
+ lv_parameterType_0_0=ruleJvmTypeReference {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule());
+ }
+ set(
+ $current,
+ "parameterType",
+ lv_parameterType_0_0,
+ "JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0());
+ }
+ lv_name_1_0=ruleValidID {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_1_0,
+ "ValidID");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleFullJvmFormalParameter
+entryRuleFullJvmFormalParameter returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getFullJvmFormalParameterRule()); }
+ iv_ruleFullJvmFormalParameter=ruleFullJvmFormalParameter
+ { $current=$iv_ruleFullJvmFormalParameter.current; }
+ EOF
+;
+
+// Rule FullJvmFormalParameter
+ruleFullJvmFormalParameter returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0());
+ }
+ lv_parameterType_0_0=ruleJvmTypeReference {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule());
+ }
+ set(
+ $current,
+ "parameterType",
+ lv_parameterType_0_0,
+ "JvmTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0());
+ }
+ lv_name_1_0=ruleValidID {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_1_0,
+ "ValidID");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleXFeatureCall
+entryRuleXFeatureCall returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXFeatureCallRule()); }
+ iv_ruleXFeatureCall=ruleXFeatureCall
+ { $current=$iv_ruleXFeatureCall.current; }
+ EOF
+;
+
+// Rule XFeatureCall
+ruleXFeatureCall returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0(),
+ $current);
+ }
+)( otherlv_1='<'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0());
+ }
+ lv_typeArguments_2_0=ruleJvmArgumentTypeReference {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ $current,
+ "typeArguments",
+ lv_typeArguments_2_0,
+ "JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_3=','
+ {
+ newLeafNode(otherlv_3, grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0());
+ }
+ lv_typeArguments_4_0=ruleJvmArgumentTypeReference {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ $current,
+ "typeArguments",
+ lv_typeArguments_4_0,
+ "JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))* otherlv_5='>'
+ {
+ newLeafNode(otherlv_5, grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3());
+ }
+)?(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXFeatureCallRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0());
+ }
+ ruleIdOrSuper {
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(((
+(
+ '('
+
+
+)
+)=>
+(
+ lv_explicitOperationCall_7_0= '('
+ {
+ newLeafNode(lv_explicitOperationCall_7_0, grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXFeatureCallRule());
+ }
+ setWithLastConsumed($current, "explicitOperationCall", true, "(");
+ }
+
+)
+)(((((
+)((
+(
+ruleJvmFormalParameter
+)
+)( ','
+(
+(
+ruleJvmFormalParameter
+)
+))*)?(
+(
+ '|'
+
+
+)
+)))=>
+(
+ {
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0());
+ }
+ lv_featureCallArguments_8_0=ruleXShortClosure {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ $current,
+ "featureCallArguments",
+ lv_featureCallArguments_8_0,
+ "XShortClosure");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |((
+(
+ {
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0());
+ }
+ lv_featureCallArguments_9_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ $current,
+ "featureCallArguments",
+ lv_featureCallArguments_9_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_10=','
+ {
+ newLeafNode(otherlv_10, grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0());
+ }
+ lv_featureCallArguments_11_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ $current,
+ "featureCallArguments",
+ lv_featureCallArguments_11_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*))? otherlv_12=')'
+ {
+ newLeafNode(otherlv_12, grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2());
+ }
+)?((((
+) '['
+))=>
+(
+ {
+ newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0());
+ }
+ lv_featureCallArguments_13_0=ruleXClosure {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+ }
+ add(
+ $current,
+ "featureCallArguments",
+ lv_featureCallArguments_13_0,
+ "XClosure");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleFeatureCallID
+entryRuleFeatureCallID returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getFeatureCallIDRule()); }
+ iv_ruleFeatureCallID=ruleFeatureCallID
+ { $current=$iv_ruleFeatureCallID.current.getText(); }
+ EOF
+;
+
+// Rule FeatureCallID
+ruleFeatureCallID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0());
+ }
+ this_ValidID_0=ruleValidID {
+ $current.merge(this_ValidID_0);
+ }
+
+ {
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ kw='extends'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1());
+ }
+
+ |
+ kw='static'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2());
+ }
+
+ |
+ kw='import'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getImportKeyword_3());
+ }
+
+ |
+ kw='extension'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4());
+ }
+)
+ ;
+
+
+
+
+
+// Entry rule entryRuleIdOrSuper
+entryRuleIdOrSuper returns [String current=null]
+ :
+ { newCompositeNode(grammarAccess.getIdOrSuperRule()); }
+ iv_ruleIdOrSuper=ruleIdOrSuper
+ { $current=$iv_ruleIdOrSuper.current.getText(); }
+ EOF
+;
+
+// Rule IdOrSuper
+ruleIdOrSuper returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0());
+ }
+ this_FeatureCallID_0=ruleFeatureCallID {
+ $current.merge(this_FeatureCallID_0);
+ }
+
+ {
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ kw='super'
+ {
+ $current.merge(kw);
+ newLeafNode(kw, grammarAccess.getIdOrSuperAccess().getSuperKeyword_1());
+ }
+)
+ ;
+
+
+
+
+
+// Entry rule entryRuleXConstructorCall
+entryRuleXConstructorCall returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXConstructorCallRule()); }
+ iv_ruleXConstructorCall=ruleXConstructorCall
+ { $current=$iv_ruleXConstructorCall.current; }
+ EOF
+;
+
+// Rule XConstructorCall
+ruleXConstructorCall returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0(),
+ $current);
+ }
+) otherlv_1='new'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXConstructorCallAccess().getNewKeyword_1());
+ }
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXConstructorCallRule());
+ }
+ }
+ {
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0());
+ }
+ ruleQualifiedName {
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((( '<'
+)=> otherlv_3='<'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0());
+ }
+ lv_typeArguments_4_0=ruleJvmArgumentTypeReference {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ $current,
+ "typeArguments",
+ lv_typeArguments_4_0,
+ "JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_5=','
+ {
+ newLeafNode(otherlv_5, grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0());
+ }
+ lv_typeArguments_6_0=ruleJvmArgumentTypeReference {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ $current,
+ "typeArguments",
+ lv_typeArguments_6_0,
+ "JvmArgumentTypeReference");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))* otherlv_7='>'
+ {
+ newLeafNode(otherlv_7, grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3());
+ }
+)?(((
+(
+ '('
+
+
+)
+)=>
+(
+ lv_explicitConstructorCall_8_0= '('
+ {
+ newLeafNode(lv_explicitConstructorCall_8_0, grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXConstructorCallRule());
+ }
+ setWithLastConsumed($current, "explicitConstructorCall", true, "(");
+ }
+
+)
+)(((((
+)((
+(
+ruleJvmFormalParameter
+)
+)( ','
+(
+(
+ruleJvmFormalParameter
+)
+))*)?(
+(
+ '|'
+
+
+)
+)))=>
+(
+ {
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0());
+ }
+ lv_arguments_9_0=ruleXShortClosure {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ $current,
+ "arguments",
+ lv_arguments_9_0,
+ "XShortClosure");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |((
+(
+ {
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0());
+ }
+ lv_arguments_10_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ $current,
+ "arguments",
+ lv_arguments_10_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_11=','
+ {
+ newLeafNode(otherlv_11, grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0());
+ }
+ lv_arguments_12_0=ruleXExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ $current,
+ "arguments",
+ lv_arguments_12_0,
+ "XExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*))? otherlv_13=')'
+ {
+ newLeafNode(otherlv_13, grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2());
+ }
+)?((((
+) '['
+))=>
+(
+ {
+ newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0());
+ }
+ lv_arguments_14_0=ruleXClosure {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+ }
+ add(
+ $current,
+ "arguments",
+ lv_arguments_14_0,
+ "XClosure");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleXBooleanLiteral
+entryRuleXBooleanLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXBooleanLiteralRule()); }
+ iv_ruleXBooleanLiteral=ruleXBooleanLiteral
+ { $current=$iv_ruleXBooleanLiteral.current; }
+ EOF
+;
+
+// Rule XBooleanLiteral
+ruleXBooleanLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0(),
+ $current);
+ }
+)( otherlv_1='false'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0());
+ }
+
+ |(
+(
+ lv_isTrue_2_0= 'true'
+ {
+ newLeafNode(lv_isTrue_2_0, grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXBooleanLiteralRule());
+ }
+ setWithLastConsumed($current, "isTrue", true, "true");
+ }
+
+)
+)))
+;
+
+
+
+
+
+// Entry rule entryRuleXNullLiteral
+entryRuleXNullLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXNullLiteralRule()); }
+ iv_ruleXNullLiteral=ruleXNullLiteral
+ { $current=$iv_ruleXNullLiteral.current; }
+ EOF
+;
+
+// Rule XNullLiteral
+ruleXNullLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0(),
+ $current);
+ }
+) otherlv_1='null'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getXNullLiteralAccess().getNullKeyword_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleXNumberLiteral
+entryRuleXNumberLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getXNumberLiteralRule()); }
+ iv_ruleXNumberLiteral=ruleXNumberLiteral
+ { $current=$iv_ruleXNumberLiteral.current; }
+ EOF
+;
+
+// Rule XNumberLiteral
+ruleXNumberLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0(),
+ $current);
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0());
+ }
+ lv_value_1_0=ruleNumber {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getXNumberLiteralRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_1_0,
+ "Number");
+ afterParserOrEnumRuleCall();

Back to the top