Skip to main content
summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to 'org.eclipse.osbp.xtext.table.ui/src-gen/org/eclipse/osbp/xtext/table/ui/contentassist/antlr/internal/InternalTableDSL.g')
-rw-r--r--org.eclipse.osbp.xtext.table.ui/src-gen/org/eclipse/osbp/xtext/table/ui/contentassist/antlr/internal/InternalTableDSL.g10014
1 files changed, 10014 insertions, 0 deletions
diff --git a/org.eclipse.osbp.xtext.table.ui/src-gen/org/eclipse/osbp/xtext/table/ui/contentassist/antlr/internal/InternalTableDSL.g b/org.eclipse.osbp.xtext.table.ui/src-gen/org/eclipse/osbp/xtext/table/ui/contentassist/antlr/internal/InternalTableDSL.g
new file mode 100644
index 0000000..f67e44a
--- /dev/null
+++ b/org.eclipse.osbp.xtext.table.ui/src-gen/org/eclipse/osbp/xtext/table/ui/contentassist/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=AbstractInternalContentAssistParser;
+ backtrack=true;
+
+}
+
+@lexer::header {
+package org.eclipse.osbp.xtext.table.ui.contentassist.antlr.internal;
+
+// Hack: Use our own Lexer superclass by means of import.
+// Currently there is no other way to specify the superclass for the lexer.
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.Lexer;
+}
+
+@parser::header {
+package org.eclipse.osbp.xtext.table.ui.contentassist.antlr.internal;
+
+import java.io.InputStream;
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.*;
+import org.eclipse.xtext.parser.impl.*;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.DFA;
+import org.eclipse.osbp.xtext.table.services.TableDSLGrammarAccess;
+
+}
+
+@parser::members {
+
+ private TableDSLGrammarAccess grammarAccess;
+
+ public void setGrammarAccess(TableDSLGrammarAccess grammarAccess) {
+ this.grammarAccess = grammarAccess;
+ }
+
+ @Override
+ protected Grammar getGrammar() {
+ return grammarAccess.getGrammar();
+ }
+
+ @Override
+ protected String getValueForTokenName(String tokenName) {
+ return tokenName;
+ }
+
+}
+
+
+
+
+// Entry rule entryRuleTableModel
+entryRuleTableModel
+:
+{ before(grammarAccess.getTableModelRule()); }
+ ruleTableModel
+{ after(grammarAccess.getTableModelRule()); }
+ EOF
+;
+
+// Rule TableModel
+ruleTableModel
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableModelAccess().getPackagesAssignment()); }
+(rule__TableModel__PackagesAssignment)*
+{ after(grammarAccess.getTableModelAccess().getPackagesAssignment()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTablePackage
+entryRuleTablePackage
+:
+{ before(grammarAccess.getTablePackageRule()); }
+ ruleTablePackage
+{ after(grammarAccess.getTablePackageRule()); }
+ EOF
+;
+
+// Rule TablePackage
+ruleTablePackage
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTablePackageAccess().getGroup()); }
+(rule__TablePackage__Group__0)
+{ after(grammarAccess.getTablePackageAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTable
+entryRuleTable
+:
+{ before(grammarAccess.getTableRule()); }
+ ruleTable
+{ after(grammarAccess.getTableRule()); }
+ EOF
+;
+
+// Rule Table
+ruleTable
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableAccess().getGroup()); }
+(rule__Table__Group__0)
+{ after(grammarAccess.getTableAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableOption
+entryRuleTableOption
+:
+{ before(grammarAccess.getTableOptionRule()); }
+ ruleTableOption
+{ after(grammarAccess.getTableOptionRule()); }
+ EOF
+;
+
+// Rule TableOption
+ruleTableOption
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableOptionAccess().getAlternatives()); }
+(rule__TableOption__Alternatives)
+{ after(grammarAccess.getTableOptionAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableSelection
+entryRuleTableSelection
+:
+{ before(grammarAccess.getTableSelectionRule()); }
+ ruleTableSelection
+{ after(grammarAccess.getTableSelectionRule()); }
+ EOF
+;
+
+// Rule TableSelection
+ruleTableSelection
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableSelectionAccess().getGroup()); }
+(rule__TableSelection__Group__0)
+{ after(grammarAccess.getTableSelectionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableTable
+entryRuleTableTable
+:
+{ before(grammarAccess.getTableTableRule()); }
+ ruleTableTable
+{ after(grammarAccess.getTableTableRule()); }
+ EOF
+;
+
+// Rule TableTable
+ruleTableTable
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableTableAccess().getGroup()); }
+(rule__TableTable__Group__0)
+{ after(grammarAccess.getTableTableAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTablePreorder
+entryRuleTablePreorder
+:
+{ before(grammarAccess.getTablePreorderRule()); }
+ ruleTablePreorder
+{ after(grammarAccess.getTablePreorderRule()); }
+ EOF
+;
+
+// Rule TablePreorder
+ruleTablePreorder
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTablePreorderAccess().getGroup()); }
+(rule__TablePreorder__Group__0)
+{ after(grammarAccess.getTablePreorderAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableValue
+entryRuleTableValue
+:
+{ before(grammarAccess.getTableValueRule()); }
+ ruleTableValue
+{ after(grammarAccess.getTableValueRule()); }
+ EOF
+;
+
+// Rule TableValue
+ruleTableValue
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableValueAccess().getGroup()); }
+(rule__TableValue__Group__0)
+{ after(grammarAccess.getTableValueAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableFormatter
+entryRuleTableFormatter
+:
+{ before(grammarAccess.getTableFormatterRule()); }
+ ruleTableFormatter
+{ after(grammarAccess.getTableFormatterRule()); }
+ EOF
+;
+
+// Rule TableFormatter
+ruleTableFormatter
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableFormatterAccess().getGroup()); }
+(rule__TableFormatter__Group__0)
+{ after(grammarAccess.getTableFormatterAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableImage
+entryRuleTableImage
+:
+{ before(grammarAccess.getTableImageRule()); }
+ ruleTableImage
+{ after(grammarAccess.getTableImageRule()); }
+ EOF
+;
+
+// Rule TableImage
+ruleTableImage
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableImageAccess().getGroup()); }
+(rule__TableImage__Group__0)
+{ after(grammarAccess.getTableImageAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableTooltipPattern
+entryRuleTableTooltipPattern
+:
+{ before(grammarAccess.getTableTooltipPatternRule()); }
+ ruleTableTooltipPattern
+{ after(grammarAccess.getTableTooltipPatternRule()); }
+ EOF
+;
+
+// Rule TableTooltipPattern
+ruleTableTooltipPattern
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableTooltipPatternAccess().getGroup()); }
+(rule__TableTooltipPattern__Group__0)
+{ after(grammarAccess.getTableTooltipPatternAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableValueElement
+entryRuleTableValueElement
+:
+{ before(grammarAccess.getTableValueElementRule()); }
+ ruleTableValueElement
+{ after(grammarAccess.getTableValueElementRule()); }
+ EOF
+;
+
+// Rule TableValueElement
+ruleTableValueElement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableValueElementAccess().getAlternatives()); }
+(rule__TableValueElement__Alternatives)
+{ after(grammarAccess.getTableValueElementAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableTask
+entryRuleTableTask
+:
+{ before(grammarAccess.getTableTaskRule()); }
+ ruleTableTask
+{ after(grammarAccess.getTableTaskRule()); }
+ EOF
+;
+
+// Rule TableTask
+ruleTableTask
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableTaskAccess().getGroup()); }
+(rule__TableTask__Group__0)
+{ after(grammarAccess.getTableTaskAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableAllColumns
+entryRuleTableAllColumns
+:
+{ before(grammarAccess.getTableAllColumnsRule()); }
+ ruleTableAllColumns
+{ after(grammarAccess.getTableAllColumnsRule()); }
+ EOF
+;
+
+// Rule TableAllColumns
+ruleTableAllColumns
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableAllColumnsAccess().getGroup()); }
+(rule__TableAllColumns__Group__0)
+{ after(grammarAccess.getTableAllColumnsAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableOrdinal
+entryRuleTableOrdinal
+:
+{ before(grammarAccess.getTableOrdinalRule()); }
+ ruleTableOrdinal
+{ after(grammarAccess.getTableOrdinalRule()); }
+ EOF
+;
+
+// Rule TableOrdinal
+ruleTableOrdinal
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableOrdinalAccess().getGroup()); }
+(rule__TableOrdinal__Group__0)
+{ after(grammarAccess.getTableOrdinalAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableColumn
+entryRuleTableColumn
+:
+{ before(grammarAccess.getTableColumnRule()); }
+ ruleTableColumn
+{ after(grammarAccess.getTableColumnRule()); }
+ EOF
+;
+
+// Rule TableColumn
+ruleTableColumn
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableColumnAccess().getGroup()); }
+(rule__TableColumn__Group__0)
+{ after(grammarAccess.getTableColumnAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableMeasure
+entryRuleTableMeasure
+:
+{ before(grammarAccess.getTableMeasureRule()); }
+ ruleTableMeasure
+{ after(grammarAccess.getTableMeasureRule()); }
+ EOF
+;
+
+// Rule TableMeasure
+ruleTableMeasure
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableMeasureAccess().getGroup()); }
+(rule__TableMeasure__Group__0)
+{ after(grammarAccess.getTableMeasureAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableDerived
+entryRuleTableDerived
+:
+{ before(grammarAccess.getTableDerivedRule()); }
+ ruleTableDerived
+{ after(grammarAccess.getTableDerivedRule()); }
+ EOF
+;
+
+// Rule TableDerived
+ruleTableDerived
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableDerivedAccess().getGroup()); }
+(rule__TableDerived__Group__0)
+{ after(grammarAccess.getTableDerivedAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableHierarchy
+entryRuleTableHierarchy
+:
+{ before(grammarAccess.getTableHierarchyRule()); }
+ ruleTableHierarchy
+{ after(grammarAccess.getTableHierarchyRule()); }
+ EOF
+;
+
+// Rule TableHierarchy
+ruleTableHierarchy
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableHierarchyAccess().getGroup()); }
+(rule__TableHierarchy__Group__0)
+{ after(grammarAccess.getTableHierarchyAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableProperty
+entryRuleTableProperty
+:
+{ before(grammarAccess.getTablePropertyRule()); }
+ ruleTableProperty
+{ after(grammarAccess.getTablePropertyRule()); }
+ EOF
+;
+
+// Rule TableProperty
+ruleTableProperty
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTablePropertyAccess().getGroup()); }
+(rule__TableProperty__Group__0)
+{ after(grammarAccess.getTablePropertyAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableAggregation
+entryRuleTableAggregation
+:
+{ before(grammarAccess.getTableAggregationRule()); }
+ ruleTableAggregation
+{ after(grammarAccess.getTableAggregationRule()); }
+ EOF
+;
+
+// Rule TableAggregation
+ruleTableAggregation
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableAggregationAccess().getGroup()); }
+(rule__TableAggregation__Group__0)
+{ after(grammarAccess.getTableAggregationAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableInterval
+entryRuleTableInterval
+:
+{ before(grammarAccess.getTableIntervalRule()); }
+ ruleTableInterval
+{ after(grammarAccess.getTableIntervalRule()); }
+ EOF
+;
+
+// Rule TableInterval
+ruleTableInterval
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableIntervalAccess().getAlternatives()); }
+(rule__TableInterval__Alternatives)
+{ after(grammarAccess.getTableIntervalAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableNumberInterval
+entryRuleTableNumberInterval
+:
+{ before(grammarAccess.getTableNumberIntervalRule()); }
+ ruleTableNumberInterval
+{ after(grammarAccess.getTableNumberIntervalRule()); }
+ EOF
+;
+
+// Rule TableNumberInterval
+ruleTableNumberInterval
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableNumberIntervalAccess().getGroup()); }
+(rule__TableNumberInterval__Group__0)
+{ after(grammarAccess.getTableNumberIntervalAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableDateDayInterval
+entryRuleTableDateDayInterval
+:
+{ before(grammarAccess.getTableDateDayIntervalRule()); }
+ ruleTableDateDayInterval
+{ after(grammarAccess.getTableDateDayIntervalRule()); }
+ EOF
+;
+
+// Rule TableDateDayInterval
+ruleTableDateDayInterval
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableDateDayIntervalAccess().getGroup()); }
+(rule__TableDateDayInterval__Group__0)
+{ after(grammarAccess.getTableDateDayIntervalAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableLookup
+entryRuleTableLookup
+:
+{ before(grammarAccess.getTableLookupRule()); }
+ ruleTableLookup
+{ after(grammarAccess.getTableLookupRule()); }
+ EOF
+;
+
+// Rule TableLookup
+ruleTableLookup
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableLookupAccess().getAlternatives()); }
+(rule__TableLookup__Alternatives)
+{ after(grammarAccess.getTableLookupAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableNumberLookup
+entryRuleTableNumberLookup
+:
+{ before(grammarAccess.getTableNumberLookupRule()); }
+ ruleTableNumberLookup
+{ after(grammarAccess.getTableNumberLookupRule()); }
+ EOF
+;
+
+// Rule TableNumberLookup
+ruleTableNumberLookup
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableNumberLookupAccess().getGroup()); }
+(rule__TableNumberLookup__Group__0)
+{ after(grammarAccess.getTableNumberLookupAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableStringLookup
+entryRuleTableStringLookup
+:
+{ before(grammarAccess.getTableStringLookupRule()); }
+ ruleTableStringLookup
+{ after(grammarAccess.getTableStringLookupRule()); }
+ EOF
+;
+
+// Rule TableStringLookup
+ruleTableStringLookup
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableStringLookupAccess().getGroup()); }
+(rule__TableStringLookup__Group__0)
+{ after(grammarAccess.getTableStringLookupAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableDateDayLookup
+entryRuleTableDateDayLookup
+:
+{ before(grammarAccess.getTableDateDayLookupRule()); }
+ ruleTableDateDayLookup
+{ after(grammarAccess.getTableDateDayLookupRule()); }
+ EOF
+;
+
+// Rule TableDateDayLookup
+ruleTableDateDayLookup
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableDateDayLookupAccess().getGroup()); }
+(rule__TableDateDayLookup__Group__0)
+{ after(grammarAccess.getTableDateDayLookupAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableDatamart
+entryRuleTableDatamart
+:
+{ before(grammarAccess.getTableDatamartRule()); }
+ ruleTableDatamart
+{ after(grammarAccess.getTableDatamartRule()); }
+ EOF
+;
+
+// Rule TableDatamart
+ruleTableDatamart
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableDatamartAccess().getGroup()); }
+(rule__TableDatamart__Group__0)
+{ after(grammarAccess.getTableDatamartAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableElement
+entryRuleTableElement
+:
+{ before(grammarAccess.getTableElementRule()); }
+ ruleTableElement
+{ after(grammarAccess.getTableElementRule()); }
+ EOF
+;
+
+// Rule TableElement
+ruleTableElement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableElementAccess().getTableAxisParserRuleCall()); }
+ ruleTableAxis
+{ after(grammarAccess.getTableElementAccess().getTableAxisParserRuleCall()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableEvent
+entryRuleTableEvent
+:
+{ before(grammarAccess.getTableEventRule()); }
+ ruleTableEvent
+{ after(grammarAccess.getTableEventRule()); }
+ EOF
+;
+
+// Rule TableEvent
+ruleTableEvent
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableEventAccess().getGroup()); }
+(rule__TableEvent__Group__0)
+{ after(grammarAccess.getTableEventAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableBrokerDatamart
+entryRuleTableBrokerDatamart
+:
+{ before(grammarAccess.getTableBrokerDatamartRule()); }
+ ruleTableBrokerDatamart
+{ after(grammarAccess.getTableBrokerDatamartRule()); }
+ EOF
+;
+
+// Rule TableBrokerDatamart
+ruleTableBrokerDatamart
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableBrokerDatamartAccess().getGroup()); }
+(rule__TableBrokerDatamart__Group__0)
+{ after(grammarAccess.getTableBrokerDatamartAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableAxis
+entryRuleTableAxis
+:
+{ before(grammarAccess.getTableAxisRule()); }
+ ruleTableAxis
+{ after(grammarAccess.getTableAxisRule()); }
+ EOF
+;
+
+// Rule TableAxis
+ruleTableAxis
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableAxisAccess().getGroup()); }
+(rule__TableAxis__Group__0)
+{ after(grammarAccess.getTableAxisAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableRangeElement
+entryRuleTableRangeElement
+:
+{ before(grammarAccess.getTableRangeElementRule()); }
+ ruleTableRangeElement
+{ after(grammarAccess.getTableRangeElementRule()); }
+ EOF
+;
+
+// Rule TableRangeElement
+ruleTableRangeElement
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableRangeElementAccess().getAlternatives()); }
+(rule__TableRangeElement__Alternatives)
+{ after(grammarAccess.getTableRangeElementAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableTextColor
+entryRuleTableTextColor
+:
+{ before(grammarAccess.getTableTextColorRule()); }
+ ruleTableTextColor
+{ after(grammarAccess.getTableTextColorRule()); }
+ EOF
+;
+
+// Rule TableTextColor
+ruleTableTextColor
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableTextColorAccess().getGroup()); }
+(rule__TableTextColor__Group__0)
+{ after(grammarAccess.getTableTextColorAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableCellColor
+entryRuleTableCellColor
+:
+{ before(grammarAccess.getTableCellColorRule()); }
+ ruleTableCellColor
+{ after(grammarAccess.getTableCellColorRule()); }
+ EOF
+;
+
+// Rule TableCellColor
+ruleTableCellColor
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableCellColorAccess().getGroup()); }
+(rule__TableCellColor__Group__0)
+{ after(grammarAccess.getTableCellColorAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableIcon
+entryRuleTableIcon
+:
+{ before(grammarAccess.getTableIconRule()); }
+ ruleTableIcon
+{ after(grammarAccess.getTableIconRule()); }
+ EOF
+;
+
+// Rule TableIcon
+ruleTableIcon
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableIconAccess().getGroup()); }
+(rule__TableIcon__Group__0)
+{ after(grammarAccess.getTableIconAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableTrend
+entryRuleTableTrend
+:
+{ before(grammarAccess.getTableTrendRule()); }
+ ruleTableTrend
+{ after(grammarAccess.getTableTrendRule()); }
+ EOF
+;
+
+// Rule TableTrend
+ruleTableTrend
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableTrendAccess().getGroup()); }
+(rule__TableTrend__Group__0)
+{ after(grammarAccess.getTableTrendAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableTooltip
+entryRuleTableTooltip
+:
+{ before(grammarAccess.getTableTooltipRule()); }
+ ruleTableTooltip
+{ after(grammarAccess.getTableTooltipRule()); }
+ EOF
+;
+
+// Rule TableTooltip
+ruleTableTooltip
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableTooltipAccess().getGroup()); }
+(rule__TableTooltip__Group__0)
+{ after(grammarAccess.getTableTooltipAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableImport
+entryRuleTableImport
+:
+{ before(grammarAccess.getTableImportRule()); }
+ ruleTableImport
+{ after(grammarAccess.getTableImportRule()); }
+ EOF
+;
+
+// Rule TableImport
+ruleTableImport
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableImportAccess().getGroup()); }
+(rule__TableImport__Group__0)
+{ after(grammarAccess.getTableImportAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableGrid
+entryRuleTableGrid
+:
+{ before(grammarAccess.getTableGridRule()); }
+ ruleTableGrid
+{ after(grammarAccess.getTableGridRule()); }
+ EOF
+;
+
+// Rule TableGrid
+ruleTableGrid
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableGridAccess().getGroup()); }
+(rule__TableGrid__Group__0)
+{ after(grammarAccess.getTableGridAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableDtoDatasource
+entryRuleTableDtoDatasource
+:
+{ before(grammarAccess.getTableDtoDatasourceRule()); }
+ ruleTableDtoDatasource
+{ after(grammarAccess.getTableDtoDatasourceRule()); }
+ EOF
+;
+
+// Rule TableDtoDatasource
+ruleTableDtoDatasource
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableDtoDatasourceAccess().getGroup()); }
+(rule__TableDtoDatasource__Group__0)
+{ after(grammarAccess.getTableDtoDatasourceAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleProperty
+entryRuleProperty
+:
+{ before(grammarAccess.getPropertyRule()); }
+ ruleProperty
+{ after(grammarAccess.getPropertyRule()); }
+ EOF
+;
+
+// Rule Property
+ruleProperty
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPropertyAccess().getGroup()); }
+(rule__Property__Group__0)
+{ after(grammarAccess.getPropertyAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNestedField
+entryRuleNestedField
+:
+{ before(grammarAccess.getNestedFieldRule()); }
+ ruleNestedField
+{ after(grammarAccess.getNestedFieldRule()); }
+ EOF
+;
+
+// Rule NestedField
+ruleNestedField
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getNestedFieldAccess().getGroup()); }
+(rule__NestedField__Group__0)
+{ after(grammarAccess.getNestedFieldAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNestedPath
+entryRuleNestedPath
+:
+{ before(grammarAccess.getNestedPathRule()); }
+ ruleNestedPath
+{ after(grammarAccess.getNestedPathRule()); }
+ EOF
+;
+
+// Rule NestedPath
+ruleNestedPath
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getNestedPathAccess().getGroup()); }
+(rule__NestedPath__Group__0)
+{ after(grammarAccess.getNestedPathAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyStyle
+entryRulePropertyStyle
+:
+{ before(grammarAccess.getPropertyStyleRule()); }
+ rulePropertyStyle
+{ after(grammarAccess.getPropertyStyleRule()); }
+ EOF
+;
+
+// Rule PropertyStyle
+rulePropertyStyle
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPropertyStyleAccess().getAlternatives()); }
+(rule__PropertyStyle__Alternatives)
+{ after(grammarAccess.getPropertyStyleAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyButtonStyle
+entryRulePropertyButtonStyle
+:
+{ before(grammarAccess.getPropertyButtonStyleRule()); }
+ rulePropertyButtonStyle
+{ after(grammarAccess.getPropertyButtonStyleRule()); }
+ EOF
+;
+
+// Rule PropertyButtonStyle
+rulePropertyButtonStyle
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPropertyButtonStyleAccess().getGroup()); }
+(rule__PropertyButtonStyle__Group__0)
+{ after(grammarAccess.getPropertyButtonStyleAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyHtmlStyle
+entryRulePropertyHtmlStyle
+:
+{ before(grammarAccess.getPropertyHtmlStyleRule()); }
+ rulePropertyHtmlStyle
+{ after(grammarAccess.getPropertyHtmlStyleRule()); }
+ EOF
+;
+
+// Rule PropertyHtmlStyle
+rulePropertyHtmlStyle
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPropertyHtmlStyleAccess().getGroup()); }
+(rule__PropertyHtmlStyle__Group__0)
+{ after(grammarAccess.getPropertyHtmlStyleAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyBooleanStyle
+entryRulePropertyBooleanStyle
+:
+{ before(grammarAccess.getPropertyBooleanStyleRule()); }
+ rulePropertyBooleanStyle
+{ after(grammarAccess.getPropertyBooleanStyleRule()); }
+ EOF
+;
+
+// Rule PropertyBooleanStyle
+rulePropertyBooleanStyle
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPropertyBooleanStyleAccess().getGroup()); }
+(rule__PropertyBooleanStyle__Group__0)
+{ after(grammarAccess.getPropertyBooleanStyleAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyDateStyle
+entryRulePropertyDateStyle
+:
+{ before(grammarAccess.getPropertyDateStyleRule()); }
+ rulePropertyDateStyle
+{ after(grammarAccess.getPropertyDateStyleRule()); }
+ EOF
+;
+
+// Rule PropertyDateStyle
+rulePropertyDateStyle
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPropertyDateStyleAccess().getGroup()); }
+(rule__PropertyDateStyle__Group__0)
+{ after(grammarAccess.getPropertyDateStyleAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyNumberStyle
+entryRulePropertyNumberStyle
+:
+{ before(grammarAccess.getPropertyNumberStyleRule()); }
+ rulePropertyNumberStyle
+{ after(grammarAccess.getPropertyNumberStyleRule()); }
+ EOF
+;
+
+// Rule PropertyNumberStyle
+rulePropertyNumberStyle
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPropertyNumberStyleAccess().getGroup()); }
+(rule__PropertyNumberStyle__Group__0)
+{ after(grammarAccess.getPropertyNumberStyleAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyProgressbarStyle
+entryRulePropertyProgressbarStyle
+:
+{ before(grammarAccess.getPropertyProgressbarStyleRule()); }
+ rulePropertyProgressbarStyle
+{ after(grammarAccess.getPropertyProgressbarStyleRule()); }
+ EOF
+;
+
+// Rule PropertyProgressbarStyle
+rulePropertyProgressbarStyle
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPropertyProgressbarStyleAccess().getGroup()); }
+(rule__PropertyProgressbarStyle__Group__0)
+{ after(grammarAccess.getPropertyProgressbarStyleAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleGridPropIndicatorStyle
+entryRuleGridPropIndicatorStyle
+:
+{ before(grammarAccess.getGridPropIndicatorStyleRule()); }
+ ruleGridPropIndicatorStyle
+{ after(grammarAccess.getGridPropIndicatorStyleRule()); }
+ EOF
+;
+
+// Rule GridPropIndicatorStyle
+ruleGridPropIndicatorStyle
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getGridPropIndicatorStyleAccess().getGroup()); }
+(rule__GridPropIndicatorStyle__Group__0)
+{ after(grammarAccess.getGridPropIndicatorStyleAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyQuantityStyle
+entryRulePropertyQuantityStyle
+:
+{ before(grammarAccess.getPropertyQuantityStyleRule()); }
+ rulePropertyQuantityStyle
+{ after(grammarAccess.getPropertyQuantityStyleRule()); }
+ EOF
+;
+
+// Rule PropertyQuantityStyle
+rulePropertyQuantityStyle
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPropertyQuantityStyleAccess().getGroup()); }
+(rule__PropertyQuantityStyle__Group__0)
+{ after(grammarAccess.getPropertyQuantityStyleAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyPriceStyle
+entryRulePropertyPriceStyle
+:
+{ before(grammarAccess.getPropertyPriceStyleRule()); }
+ rulePropertyPriceStyle
+{ after(grammarAccess.getPropertyPriceStyleRule()); }
+ EOF
+;
+
+// Rule PropertyPriceStyle
+rulePropertyPriceStyle
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPropertyPriceStyleAccess().getGroup()); }
+(rule__PropertyPriceStyle__Group__0)
+{ after(grammarAccess.getPropertyPriceStyleAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyTextStyle
+entryRulePropertyTextStyle
+:
+{ before(grammarAccess.getPropertyTextStyleRule()); }
+ rulePropertyTextStyle
+{ after(grammarAccess.getPropertyTextStyleRule()); }
+ EOF
+;
+
+// Rule PropertyTextStyle
+rulePropertyTextStyle
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPropertyTextStyleAccess().getGroup()); }
+(rule__PropertyTextStyle__Group__0)
+{ after(grammarAccess.getPropertyTextStyleAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyImageStyle
+entryRulePropertyImageStyle
+:
+{ before(grammarAccess.getPropertyImageStyleRule()); }
+ rulePropertyImageStyle
+{ after(grammarAccess.getPropertyImageStyleRule()); }
+ EOF
+;
+
+// Rule PropertyImageStyle
+rulePropertyImageStyle
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPropertyImageStyleAccess().getGroup()); }
+(rule__PropertyImageStyle__Group__0)
+{ after(grammarAccess.getPropertyImageStyleAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleStyleConfig
+entryRuleStyleConfig
+:
+{ before(grammarAccess.getStyleConfigRule()); }
+ ruleStyleConfig
+{ after(grammarAccess.getStyleConfigRule()); }
+ EOF
+;
+
+// Rule StyleConfig
+ruleStyleConfig
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getStyleConfigAccess().getAlternatives()); }
+(rule__StyleConfig__Alternatives)
+{ after(grammarAccess.getStyleConfigAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNumericToResourceStyleConfig
+entryRuleNumericToResourceStyleConfig
+:
+{ before(grammarAccess.getNumericToResourceStyleConfigRule()); }
+ ruleNumericToResourceStyleConfig
+{ after(grammarAccess.getNumericToResourceStyleConfigRule()); }
+ EOF
+;
+
+// Rule NumericToResourceStyleConfig
+ruleNumericToResourceStyleConfig
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getNumericToResourceStyleConfigAccess().getGroup()); }
+(rule__NumericToResourceStyleConfig__Group__0)
+{ after(grammarAccess.getNumericToResourceStyleConfigAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleStringToResourceStyleConfig
+entryRuleStringToResourceStyleConfig
+:
+{ before(grammarAccess.getStringToResourceStyleConfigRule()); }
+ ruleStringToResourceStyleConfig
+{ after(grammarAccess.getStringToResourceStyleConfigRule()); }
+ EOF
+;
+
+// Rule StringToResourceStyleConfig
+ruleStringToResourceStyleConfig
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getStringToResourceStyleConfigAccess().getGroup()); }
+(rule__StringToResourceStyleConfig__Group__0)
+{ after(grammarAccess.getStringToResourceStyleConfigAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLInt
+entryRuleLInt
+:
+{ before(grammarAccess.getLIntRule()); }
+ ruleLInt
+{ after(grammarAccess.getLIntRule()); }
+ EOF
+;
+
+// Rule LInt
+ruleLInt
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getLIntAccess().getGroup()); }
+(rule__LInt__Group__0)
+{ after(grammarAccess.getLIntAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLDouble
+entryRuleLDouble
+:
+{ before(grammarAccess.getLDoubleRule()); }
+ ruleLDouble
+{ after(grammarAccess.getLDoubleRule()); }
+ EOF
+;
+
+// Rule LDouble
+ruleLDouble
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getLDoubleAccess().getGroup()); }
+(rule__LDouble__Group__0)
+{ after(grammarAccess.getLDoubleAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSignedNumber
+entryRuleSignedNumber
+:
+{ before(grammarAccess.getSignedNumberRule()); }
+ ruleSignedNumber
+{ after(grammarAccess.getSignedNumberRule()); }
+ EOF
+;
+
+// Rule SignedNumber
+ruleSignedNumber
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSignedNumberAccess().getGroup()); }
+(rule__SignedNumber__Group__0)
+{ after(grammarAccess.getSignedNumberAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableQualifiedNameWithWildCard
+entryRuleTableQualifiedNameWithWildCard
+:
+{ before(grammarAccess.getTableQualifiedNameWithWildCardRule()); }
+ ruleTableQualifiedNameWithWildCard
+{ after(grammarAccess.getTableQualifiedNameWithWildCardRule()); }
+ EOF
+;
+
+// Rule TableQualifiedNameWithWildCard
+ruleTableQualifiedNameWithWildCard
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTableQualifiedNameWithWildCardAccess().getGroup()); }
+(rule__TableQualifiedNameWithWildCard__Group__0)
+{ after(grammarAccess.getTableQualifiedNameWithWildCardAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleQualifiedName
+entryRuleQualifiedName
+:
+{ before(grammarAccess.getQualifiedNameRule()); }
+ ruleQualifiedName
+{ after(grammarAccess.getQualifiedNameRule()); }
+ EOF
+;
+
+// Rule QualifiedName
+ruleQualifiedName
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getQualifiedNameAccess().getGroup()); }
+(rule__QualifiedName__Group__0)
+{ after(grammarAccess.getQualifiedNameAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleValidID
+entryRuleValidID
+:
+{ before(grammarAccess.getValidIDRule()); }
+ ruleValidID
+{ after(grammarAccess.getValidIDRule()); }
+ EOF
+;
+
+// Rule ValidID
+ruleValidID
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); }
+ RULE_ID
+{ after(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTRANSLATABLESTRING
+entryRuleTRANSLATABLESTRING
+:
+{ before(grammarAccess.getTRANSLATABLESTRINGRule()); }
+ ruleTRANSLATABLESTRING
+{ after(grammarAccess.getTRANSLATABLESTRINGRule()); }
+ EOF
+;
+
+// Rule TRANSLATABLESTRING
+ruleTRANSLATABLESTRING
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTRANSLATABLESTRINGAccess().getSTRINGTerminalRuleCall()); }
+ RULE_STRING
+{ after(grammarAccess.getTRANSLATABLESTRINGAccess().getSTRINGTerminalRuleCall()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTRANSLATABLEID
+entryRuleTRANSLATABLEID
+:
+{ before(grammarAccess.getTRANSLATABLEIDRule()); }
+ ruleTRANSLATABLEID
+{ after(grammarAccess.getTRANSLATABLEIDRule()); }
+ EOF
+;
+
+// Rule TRANSLATABLEID
+ruleTRANSLATABLEID
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTRANSLATABLEIDAccess().getIDTerminalRuleCall()); }
+ RULE_ID
+{ after(grammarAccess.getTRANSLATABLEIDAccess().getIDTerminalRuleCall()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXAnnotation
+entryRuleXAnnotation
+:
+{ before(grammarAccess.getXAnnotationRule()); }
+ ruleXAnnotation
+{ after(grammarAccess.getXAnnotationRule()); }
+ EOF
+;
+
+// Rule XAnnotation
+ruleXAnnotation
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXAnnotationAccess().getGroup()); }
+(rule__XAnnotation__Group__0)
+{ after(grammarAccess.getXAnnotationAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXAnnotationElementValuePair
+entryRuleXAnnotationElementValuePair
+:
+{ before(grammarAccess.getXAnnotationElementValuePairRule()); }
+ ruleXAnnotationElementValuePair
+{ after(grammarAccess.getXAnnotationElementValuePairRule()); }
+ EOF
+;
+
+// Rule XAnnotationElementValuePair
+ruleXAnnotationElementValuePair
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXAnnotationElementValuePairAccess().getGroup()); }
+(rule__XAnnotationElementValuePair__Group__0)
+{ after(grammarAccess.getXAnnotationElementValuePairAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXAnnotationElementValueOrCommaList
+entryRuleXAnnotationElementValueOrCommaList
+:
+{ before(grammarAccess.getXAnnotationElementValueOrCommaListRule()); }
+ ruleXAnnotationElementValueOrCommaList
+{ after(grammarAccess.getXAnnotationElementValueOrCommaListRule()); }
+ EOF
+;
+
+// Rule XAnnotationElementValueOrCommaList
+ruleXAnnotationElementValueOrCommaList
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getAlternatives()); }
+(rule__XAnnotationElementValueOrCommaList__Alternatives)
+{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXAnnotationElementValue
+entryRuleXAnnotationElementValue
+:
+{ before(grammarAccess.getXAnnotationElementValueRule()); }
+ ruleXAnnotationElementValue
+{ after(grammarAccess.getXAnnotationElementValueRule()); }
+ EOF
+;
+
+// Rule XAnnotationElementValue
+ruleXAnnotationElementValue
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXAnnotationElementValueAccess().getAlternatives()); }
+(rule__XAnnotationElementValue__Alternatives)
+{ after(grammarAccess.getXAnnotationElementValueAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXAnnotationOrExpression
+entryRuleXAnnotationOrExpression
+:
+{ before(grammarAccess.getXAnnotationOrExpressionRule()); }
+ ruleXAnnotationOrExpression
+{ after(grammarAccess.getXAnnotationOrExpressionRule()); }
+ EOF
+;
+
+// Rule XAnnotationOrExpression
+ruleXAnnotationOrExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXAnnotationOrExpressionAccess().getAlternatives()); }
+(rule__XAnnotationOrExpression__Alternatives)
+{ after(grammarAccess.getXAnnotationOrExpressionAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXExpression
+entryRuleXExpression
+:
+{ before(grammarAccess.getXExpressionRule()); }
+ ruleXExpression
+{ after(grammarAccess.getXExpressionRule()); }
+ EOF
+;
+
+// Rule XExpression
+ruleXExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); }
+ ruleXAssignment
+{ after(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXAssignment
+entryRuleXAssignment
+:
+{ before(grammarAccess.getXAssignmentRule()); }
+ ruleXAssignment
+{ after(grammarAccess.getXAssignmentRule()); }
+ EOF
+;
+
+// Rule XAssignment
+ruleXAssignment
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXAssignmentAccess().getAlternatives()); }
+(rule__XAssignment__Alternatives)
+{ after(grammarAccess.getXAssignmentAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleOpSingleAssign
+entryRuleOpSingleAssign
+:
+{ before(grammarAccess.getOpSingleAssignRule()); }
+ ruleOpSingleAssign
+{ after(grammarAccess.getOpSingleAssignRule()); }
+ EOF
+;
+
+// Rule OpSingleAssign
+ruleOpSingleAssign
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); }
+
+ '='
+
+{ after(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleOpMultiAssign
+entryRuleOpMultiAssign
+:
+{ before(grammarAccess.getOpMultiAssignRule()); }
+ ruleOpMultiAssign
+{ after(grammarAccess.getOpMultiAssignRule()); }
+ EOF
+;
+
+// Rule OpMultiAssign
+ruleOpMultiAssign
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getOpMultiAssignAccess().getAlternatives()); }
+(rule__OpMultiAssign__Alternatives)
+{ after(grammarAccess.getOpMultiAssignAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXOrExpression
+entryRuleXOrExpression
+:
+{ before(grammarAccess.getXOrExpressionRule()); }
+ ruleXOrExpression
+{ after(grammarAccess.getXOrExpressionRule()); }
+ EOF
+;
+
+// Rule XOrExpression
+ruleXOrExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXOrExpressionAccess().getGroup()); }
+(rule__XOrExpression__Group__0)
+{ after(grammarAccess.getXOrExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleOpOr
+entryRuleOpOr
+:
+{ before(grammarAccess.getOpOrRule()); }
+ ruleOpOr
+{ after(grammarAccess.getOpOrRule()); }
+ EOF
+;
+
+// Rule OpOr
+ruleOpOr
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); }
+
+ '||'
+
+{ after(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXAndExpression
+entryRuleXAndExpression
+:
+{ before(grammarAccess.getXAndExpressionRule()); }
+ ruleXAndExpression
+{ after(grammarAccess.getXAndExpressionRule()); }
+ EOF
+;
+
+// Rule XAndExpression
+ruleXAndExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXAndExpressionAccess().getGroup()); }
+(rule__XAndExpression__Group__0)
+{ after(grammarAccess.getXAndExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleOpAnd
+entryRuleOpAnd
+:
+{ before(grammarAccess.getOpAndRule()); }
+ ruleOpAnd
+{ after(grammarAccess.getOpAndRule()); }
+ EOF
+;
+
+// Rule OpAnd
+ruleOpAnd
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); }
+
+ '&&'
+
+{ after(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXEqualityExpression
+entryRuleXEqualityExpression
+:
+{ before(grammarAccess.getXEqualityExpressionRule()); }
+ ruleXEqualityExpression
+{ after(grammarAccess.getXEqualityExpressionRule()); }
+ EOF
+;
+
+// Rule XEqualityExpression
+ruleXEqualityExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXEqualityExpressionAccess().getGroup()); }
+(rule__XEqualityExpression__Group__0)
+{ after(grammarAccess.getXEqualityExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleOpEquality
+entryRuleOpEquality
+:
+{ before(grammarAccess.getOpEqualityRule()); }
+ ruleOpEquality
+{ after(grammarAccess.getOpEqualityRule()); }
+ EOF
+;
+
+// Rule OpEquality
+ruleOpEquality
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getOpEqualityAccess().getAlternatives()); }
+(rule__OpEquality__Alternatives)
+{ after(grammarAccess.getOpEqualityAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXRelationalExpression
+entryRuleXRelationalExpression
+:
+{ before(grammarAccess.getXRelationalExpressionRule()); }
+ ruleXRelationalExpression
+{ after(grammarAccess.getXRelationalExpressionRule()); }
+ EOF
+;
+
+// Rule XRelationalExpression
+ruleXRelationalExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXRelationalExpressionAccess().getGroup()); }
+(rule__XRelationalExpression__Group__0)
+{ after(grammarAccess.getXRelationalExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleOpCompare
+entryRuleOpCompare
+:
+{ before(grammarAccess.getOpCompareRule()); }
+ ruleOpCompare
+{ after(grammarAccess.getOpCompareRule()); }
+ EOF
+;
+
+// Rule OpCompare
+ruleOpCompare
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getOpCompareAccess().getAlternatives()); }
+(rule__OpCompare__Alternatives)
+{ after(grammarAccess.getOpCompareAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXOtherOperatorExpression
+entryRuleXOtherOperatorExpression
+:
+{ before(grammarAccess.getXOtherOperatorExpressionRule()); }
+ ruleXOtherOperatorExpression
+{ after(grammarAccess.getXOtherOperatorExpressionRule()); }
+ EOF
+;
+
+// Rule XOtherOperatorExpression
+ruleXOtherOperatorExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); }
+(rule__XOtherOperatorExpression__Group__0)
+{ after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleOpOther
+entryRuleOpOther
+:
+{ before(grammarAccess.getOpOtherRule()); }
+ ruleOpOther
+{ after(grammarAccess.getOpOtherRule()); }
+ EOF
+;
+
+// Rule OpOther
+ruleOpOther
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getOpOtherAccess().getAlternatives()); }
+(rule__OpOther__Alternatives)
+{ after(grammarAccess.getOpOtherAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXAdditiveExpression
+entryRuleXAdditiveExpression
+:
+{ before(grammarAccess.getXAdditiveExpressionRule()); }
+ ruleXAdditiveExpression
+{ after(grammarAccess.getXAdditiveExpressionRule()); }
+ EOF
+;
+
+// Rule XAdditiveExpression
+ruleXAdditiveExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXAdditiveExpressionAccess().getGroup()); }
+(rule__XAdditiveExpression__Group__0)
+{ after(grammarAccess.getXAdditiveExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleOpAdd
+entryRuleOpAdd
+:
+{ before(grammarAccess.getOpAddRule()); }
+ ruleOpAdd
+{ after(grammarAccess.getOpAddRule()); }
+ EOF
+;
+
+// Rule OpAdd
+ruleOpAdd
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getOpAddAccess().getAlternatives()); }
+(rule__OpAdd__Alternatives)
+{ after(grammarAccess.getOpAddAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXMultiplicativeExpression
+entryRuleXMultiplicativeExpression
+:
+{ before(grammarAccess.getXMultiplicativeExpressionRule()); }
+ ruleXMultiplicativeExpression
+{ after(grammarAccess.getXMultiplicativeExpressionRule()); }
+ EOF
+;
+
+// Rule XMultiplicativeExpression
+ruleXMultiplicativeExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); }
+(rule__XMultiplicativeExpression__Group__0)
+{ after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleOpMulti
+entryRuleOpMulti
+:
+{ before(grammarAccess.getOpMultiRule()); }
+ ruleOpMulti
+{ after(grammarAccess.getOpMultiRule()); }
+ EOF
+;
+
+// Rule OpMulti
+ruleOpMulti
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getOpMultiAccess().getAlternatives()); }
+(rule__OpMulti__Alternatives)
+{ after(grammarAccess.getOpMultiAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXUnaryOperation
+entryRuleXUnaryOperation
+:
+{ before(grammarAccess.getXUnaryOperationRule()); }
+ ruleXUnaryOperation
+{ after(grammarAccess.getXUnaryOperationRule()); }
+ EOF
+;
+
+// Rule XUnaryOperation
+ruleXUnaryOperation
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXUnaryOperationAccess().getAlternatives()); }
+(rule__XUnaryOperation__Alternatives)
+{ after(grammarAccess.getXUnaryOperationAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleOpUnary
+entryRuleOpUnary
+:
+{ before(grammarAccess.getOpUnaryRule()); }
+ ruleOpUnary
+{ after(grammarAccess.getOpUnaryRule()); }
+ EOF
+;
+
+// Rule OpUnary
+ruleOpUnary
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getOpUnaryAccess().getAlternatives()); }
+(rule__OpUnary__Alternatives)
+{ after(grammarAccess.getOpUnaryAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXCastedExpression
+entryRuleXCastedExpression
+:
+{ before(grammarAccess.getXCastedExpressionRule()); }
+ ruleXCastedExpression
+{ after(grammarAccess.getXCastedExpressionRule()); }
+ EOF
+;
+
+// Rule XCastedExpression
+ruleXCastedExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXCastedExpressionAccess().getGroup()); }
+(rule__XCastedExpression__Group__0)
+{ after(grammarAccess.getXCastedExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXPostfixOperation
+entryRuleXPostfixOperation
+:
+{ before(grammarAccess.getXPostfixOperationRule()); }
+ ruleXPostfixOperation
+{ after(grammarAccess.getXPostfixOperationRule()); }
+ EOF
+;
+
+// Rule XPostfixOperation
+ruleXPostfixOperation
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXPostfixOperationAccess().getGroup()); }
+(rule__XPostfixOperation__Group__0)
+{ after(grammarAccess.getXPostfixOperationAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleOpPostfix
+entryRuleOpPostfix
+:
+{ before(grammarAccess.getOpPostfixRule()); }
+ ruleOpPostfix
+{ after(grammarAccess.getOpPostfixRule()); }
+ EOF
+;
+
+// Rule OpPostfix
+ruleOpPostfix
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getOpPostfixAccess().getAlternatives()); }
+(rule__OpPostfix__Alternatives)
+{ after(grammarAccess.getOpPostfixAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXMemberFeatureCall
+entryRuleXMemberFeatureCall
+:
+{ before(grammarAccess.getXMemberFeatureCallRule()); }
+ ruleXMemberFeatureCall
+{ after(grammarAccess.getXMemberFeatureCallRule()); }
+ EOF
+;
+
+// Rule XMemberFeatureCall
+ruleXMemberFeatureCall
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup()); }
+(rule__XMemberFeatureCall__Group__0)
+{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXPrimaryExpression
+entryRuleXPrimaryExpression
+:
+{ before(grammarAccess.getXPrimaryExpressionRule()); }
+ ruleXPrimaryExpression
+{ after(grammarAccess.getXPrimaryExpressionRule()); }
+ EOF
+;
+
+// Rule XPrimaryExpression
+ruleXPrimaryExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); }
+(rule__XPrimaryExpression__Alternatives)
+{ after(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXLiteral
+entryRuleXLiteral
+:
+{ before(grammarAccess.getXLiteralRule()); }
+ ruleXLiteral
+{ after(grammarAccess.getXLiteralRule()); }
+ EOF
+;
+
+// Rule XLiteral
+ruleXLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXLiteralAccess().getAlternatives()); }
+(rule__XLiteral__Alternatives)
+{ after(grammarAccess.getXLiteralAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXCollectionLiteral
+entryRuleXCollectionLiteral
+:
+{ before(grammarAccess.getXCollectionLiteralRule()); }
+ ruleXCollectionLiteral
+{ after(grammarAccess.getXCollectionLiteralRule()); }
+ EOF
+;
+
+// Rule XCollectionLiteral
+ruleXCollectionLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); }
+(rule__XCollectionLiteral__Alternatives)
+{ after(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXSetLiteral
+entryRuleXSetLiteral
+:
+{ before(grammarAccess.getXSetLiteralRule()); }
+ ruleXSetLiteral
+{ after(grammarAccess.getXSetLiteralRule()); }
+ EOF
+;
+
+// Rule XSetLiteral
+ruleXSetLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXSetLiteralAccess().getGroup()); }
+(rule__XSetLiteral__Group__0)
+{ after(grammarAccess.getXSetLiteralAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXListLiteral
+entryRuleXListLiteral
+:
+{ before(grammarAccess.getXListLiteralRule()); }
+ ruleXListLiteral
+{ after(grammarAccess.getXListLiteralRule()); }
+ EOF
+;
+
+// Rule XListLiteral
+ruleXListLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXListLiteralAccess().getGroup()); }
+(rule__XListLiteral__Group__0)
+{ after(grammarAccess.getXListLiteralAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXClosure
+entryRuleXClosure
+:
+{ before(grammarAccess.getXClosureRule()); }
+ ruleXClosure
+{ after(grammarAccess.getXClosureRule()); }
+ EOF
+;
+
+// Rule XClosure
+ruleXClosure
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXClosureAccess().getGroup()); }
+(rule__XClosure__Group__0)
+{ after(grammarAccess.getXClosureAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXExpressionInClosure
+entryRuleXExpressionInClosure
+:
+{ before(grammarAccess.getXExpressionInClosureRule()); }
+ ruleXExpressionInClosure
+{ after(grammarAccess.getXExpressionInClosureRule()); }
+ EOF
+;
+
+// Rule XExpressionInClosure
+ruleXExpressionInClosure
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXExpressionInClosureAccess().getGroup()); }
+(rule__XExpressionInClosure__Group__0)
+{ after(grammarAccess.getXExpressionInClosureAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXShortClosure
+entryRuleXShortClosure
+:
+{ before(grammarAccess.getXShortClosureRule()); }
+ ruleXShortClosure
+{ after(grammarAccess.getXShortClosureRule()); }
+ EOF
+;
+
+// Rule XShortClosure
+ruleXShortClosure
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXShortClosureAccess().getGroup()); }
+(rule__XShortClosure__Group__0)
+{ after(grammarAccess.getXShortClosureAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXParenthesizedExpression
+entryRuleXParenthesizedExpression
+:
+{ before(grammarAccess.getXParenthesizedExpressionRule()); }
+ ruleXParenthesizedExpression
+{ after(grammarAccess.getXParenthesizedExpressionRule()); }
+ EOF
+;
+
+// Rule XParenthesizedExpression
+ruleXParenthesizedExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); }
+(rule__XParenthesizedExpression__Group__0)
+{ after(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXIfExpression
+entryRuleXIfExpression
+:
+{ before(grammarAccess.getXIfExpressionRule()); }
+ ruleXIfExpression
+{ after(grammarAccess.getXIfExpressionRule()); }
+ EOF
+;
+
+// Rule XIfExpression
+ruleXIfExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXIfExpressionAccess().getGroup()); }
+(rule__XIfExpression__Group__0)
+{ after(grammarAccess.getXIfExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXSwitchExpression
+entryRuleXSwitchExpression
+:
+{ before(grammarAccess.getXSwitchExpressionRule()); }
+ ruleXSwitchExpression
+{ after(grammarAccess.getXSwitchExpressionRule()); }
+ EOF
+;
+
+// Rule XSwitchExpression
+ruleXSwitchExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXSwitchExpressionAccess().getGroup()); }
+(rule__XSwitchExpression__Group__0)
+{ after(grammarAccess.getXSwitchExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXCasePart
+entryRuleXCasePart
+:
+{ before(grammarAccess.getXCasePartRule()); }
+ ruleXCasePart
+{ after(grammarAccess.getXCasePartRule()); }
+ EOF
+;
+
+// Rule XCasePart
+ruleXCasePart
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXCasePartAccess().getGroup()); }
+(rule__XCasePart__Group__0)
+{ after(grammarAccess.getXCasePartAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXForLoopExpression
+entryRuleXForLoopExpression
+:
+{ before(grammarAccess.getXForLoopExpressionRule()); }
+ ruleXForLoopExpression
+{ after(grammarAccess.getXForLoopExpressionRule()); }
+ EOF
+;
+
+// Rule XForLoopExpression
+ruleXForLoopExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXForLoopExpressionAccess().getGroup()); }
+(rule__XForLoopExpression__Group__0)
+{ after(grammarAccess.getXForLoopExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXBasicForLoopExpression
+entryRuleXBasicForLoopExpression
+:
+{ before(grammarAccess.getXBasicForLoopExpressionRule()); }
+ ruleXBasicForLoopExpression
+{ after(grammarAccess.getXBasicForLoopExpressionRule()); }
+ EOF
+;
+
+// Rule XBasicForLoopExpression
+ruleXBasicForLoopExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); }
+(rule__XBasicForLoopExpression__Group__0)
+{ after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXWhileExpression
+entryRuleXWhileExpression
+:
+{ before(grammarAccess.getXWhileExpressionRule()); }
+ ruleXWhileExpression
+{ after(grammarAccess.getXWhileExpressionRule()); }
+ EOF
+;
+
+// Rule XWhileExpression
+ruleXWhileExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXWhileExpressionAccess().getGroup()); }
+(rule__XWhileExpression__Group__0)
+{ after(grammarAccess.getXWhileExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXDoWhileExpression
+entryRuleXDoWhileExpression
+:
+{ before(grammarAccess.getXDoWhileExpressionRule()); }
+ ruleXDoWhileExpression
+{ after(grammarAccess.getXDoWhileExpressionRule()); }
+ EOF
+;
+
+// Rule XDoWhileExpression
+ruleXDoWhileExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXDoWhileExpressionAccess().getGroup()); }
+(rule__XDoWhileExpression__Group__0)
+{ after(grammarAccess.getXDoWhileExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXBlockExpression
+entryRuleXBlockExpression
+:
+{ before(grammarAccess.getXBlockExpressionRule()); }
+ ruleXBlockExpression
+{ after(grammarAccess.getXBlockExpressionRule()); }
+ EOF
+;
+
+// Rule XBlockExpression
+ruleXBlockExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXBlockExpressionAccess().getGroup()); }
+(rule__XBlockExpression__Group__0)
+{ after(grammarAccess.getXBlockExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXExpressionOrVarDeclaration
+entryRuleXExpressionOrVarDeclaration
+:
+{ before(grammarAccess.getXExpressionOrVarDeclarationRule()); }
+ ruleXExpressionOrVarDeclaration
+{ after(grammarAccess.getXExpressionOrVarDeclarationRule()); }
+ EOF
+;
+
+// Rule XExpressionOrVarDeclaration
+ruleXExpressionOrVarDeclaration
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); }
+(rule__XExpressionOrVarDeclaration__Alternatives)
+{ after(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXVariableDeclaration
+entryRuleXVariableDeclaration
+:
+{ before(grammarAccess.getXVariableDeclarationRule()); }
+ ruleXVariableDeclaration
+{ after(grammarAccess.getXVariableDeclarationRule()); }
+ EOF
+;
+
+// Rule XVariableDeclaration
+ruleXVariableDeclaration
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXVariableDeclarationAccess().getGroup()); }
+(rule__XVariableDeclaration__Group__0)
+{ after(grammarAccess.getXVariableDeclarationAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleJvmFormalParameter
+entryRuleJvmFormalParameter
+:
+{ before(grammarAccess.getJvmFormalParameterRule()); }
+ ruleJvmFormalParameter
+{ after(grammarAccess.getJvmFormalParameterRule()); }
+ EOF
+;
+
+// Rule JvmFormalParameter
+ruleJvmFormalParameter
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getJvmFormalParameterAccess().getGroup()); }
+(rule__JvmFormalParameter__Group__0)
+{ after(grammarAccess.getJvmFormalParameterAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleFullJvmFormalParameter
+entryRuleFullJvmFormalParameter
+:
+{ before(grammarAccess.getFullJvmFormalParameterRule()); }
+ ruleFullJvmFormalParameter
+{ after(grammarAccess.getFullJvmFormalParameterRule()); }
+ EOF
+;
+
+// Rule FullJvmFormalParameter
+ruleFullJvmFormalParameter
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); }
+(rule__FullJvmFormalParameter__Group__0)
+{ after(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXFeatureCall
+entryRuleXFeatureCall
+:
+{ before(grammarAccess.getXFeatureCallRule()); }
+ ruleXFeatureCall
+{ after(grammarAccess.getXFeatureCallRule()); }
+ EOF
+;
+
+// Rule XFeatureCall
+ruleXFeatureCall
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXFeatureCallAccess().getGroup()); }
+(rule__XFeatureCall__Group__0)
+{ after(grammarAccess.getXFeatureCallAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleFeatureCallID
+entryRuleFeatureCallID
+:
+{ before(grammarAccess.getFeatureCallIDRule()); }
+ ruleFeatureCallID
+{ after(grammarAccess.getFeatureCallIDRule()); }
+ EOF
+;
+
+// Rule FeatureCallID
+ruleFeatureCallID
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getFeatureCallIDAccess().getAlternatives()); }
+(rule__FeatureCallID__Alternatives)
+{ after(grammarAccess.getFeatureCallIDAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleIdOrSuper
+entryRuleIdOrSuper
+:
+{ before(grammarAccess.getIdOrSuperRule()); }
+ ruleIdOrSuper
+{ after(grammarAccess.getIdOrSuperRule()); }
+ EOF
+;
+
+// Rule IdOrSuper
+ruleIdOrSuper
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getIdOrSuperAccess().getAlternatives()); }
+(rule__IdOrSuper__Alternatives)
+{ after(grammarAccess.getIdOrSuperAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXConstructorCall
+entryRuleXConstructorCall
+:
+{ before(grammarAccess.getXConstructorCallRule()); }
+ ruleXConstructorCall
+{ after(grammarAccess.getXConstructorCallRule()); }
+ EOF
+;
+
+// Rule XConstructorCall
+ruleXConstructorCall
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXConstructorCallAccess().getGroup()); }
+(rule__XConstructorCall__Group__0)
+{ after(grammarAccess.getXConstructorCallAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXBooleanLiteral
+entryRuleXBooleanLiteral
+:
+{ before(grammarAccess.getXBooleanLiteralRule()); }
+ ruleXBooleanLiteral
+{ after(grammarAccess.getXBooleanLiteralRule()); }
+ EOF
+;
+
+// Rule XBooleanLiteral
+ruleXBooleanLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXBooleanLiteralAccess().getGroup()); }
+(rule__XBooleanLiteral__Group__0)
+{ after(grammarAccess.getXBooleanLiteralAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXNullLiteral
+entryRuleXNullLiteral
+:
+{ before(grammarAccess.getXNullLiteralRule()); }
+ ruleXNullLiteral
+{ after(grammarAccess.getXNullLiteralRule()); }
+ EOF
+;
+
+// Rule XNullLiteral
+ruleXNullLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXNullLiteralAccess().getGroup()); }
+(rule__XNullLiteral__Group__0)
+{ after(grammarAccess.getXNullLiteralAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXNumberLiteral
+entryRuleXNumberLiteral
+:
+{ before(grammarAccess.getXNumberLiteralRule()); }
+ ruleXNumberLiteral
+{ after(grammarAccess.getXNumberLiteralRule()); }
+ EOF
+;
+
+// Rule XNumberLiteral
+ruleXNumberLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXNumberLiteralAccess().getGroup()); }
+(rule__XNumberLiteral__Group__0)
+{ after(grammarAccess.getXNumberLiteralAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXStringLiteral
+entryRuleXStringLiteral
+:
+{ before(grammarAccess.getXStringLiteralRule()); }
+ ruleXStringLiteral
+{ after(grammarAccess.getXStringLiteralRule()); }
+ EOF
+;
+
+// Rule XStringLiteral
+ruleXStringLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXStringLiteralAccess().getGroup()); }
+(rule__XStringLiteral__Group__0)
+{ after(grammarAccess.getXStringLiteralAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXTypeLiteral
+entryRuleXTypeLiteral
+:
+{ before(grammarAccess.getXTypeLiteralRule()); }
+ ruleXTypeLiteral
+{ after(grammarAccess.getXTypeLiteralRule()); }
+ EOF
+;
+
+// Rule XTypeLiteral
+ruleXTypeLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXTypeLiteralAccess().getGroup()); }
+(rule__XTypeLiteral__Group__0)
+{ after(grammarAccess.getXTypeLiteralAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXThrowExpression
+entryRuleXThrowExpression
+:
+{ before(grammarAccess.getXThrowExpressionRule()); }
+ ruleXThrowExpression
+{ after(grammarAccess.getXThrowExpressionRule()); }
+ EOF
+;
+
+// Rule XThrowExpression
+ruleXThrowExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXThrowExpressionAccess().getGroup()); }
+(rule__XThrowExpression__Group__0)
+{ after(grammarAccess.getXThrowExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXReturnExpression
+entryRuleXReturnExpression
+:
+{ before(grammarAccess.getXReturnExpressionRule()); }
+ ruleXReturnExpression
+{ after(grammarAccess.getXReturnExpressionRule()); }
+ EOF
+;
+
+// Rule XReturnExpression
+ruleXReturnExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXReturnExpressionAccess().getGroup()); }
+(rule__XReturnExpression__Group__0)
+{ after(grammarAccess.getXReturnExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXTryCatchFinallyExpression
+entryRuleXTryCatchFinallyExpression
+:
+{ before(grammarAccess.getXTryCatchFinallyExpressionRule()); }
+ ruleXTryCatchFinallyExpression
+{ after(grammarAccess.getXTryCatchFinallyExpressionRule()); }
+ EOF
+;
+
+// Rule XTryCatchFinallyExpression
+ruleXTryCatchFinallyExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); }
+(rule__XTryCatchFinallyExpression__Group__0)
+{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXSynchronizedExpression
+entryRuleXSynchronizedExpression
+:
+{ before(grammarAccess.getXSynchronizedExpressionRule()); }
+ ruleXSynchronizedExpression
+{ after(grammarAccess.getXSynchronizedExpressionRule()); }
+ EOF
+;
+
+// Rule XSynchronizedExpression
+ruleXSynchronizedExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); }
+(rule__XSynchronizedExpression__Group__0)
+{ after(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXCatchClause
+entryRuleXCatchClause
+:
+{ before(grammarAccess.getXCatchClauseRule()); }
+ ruleXCatchClause
+{ after(grammarAccess.getXCatchClauseRule()); }
+ EOF
+;
+
+// Rule XCatchClause
+ruleXCatchClause
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXCatchClauseAccess().getGroup()); }
+(rule__XCatchClause__Group__0)
+{ after(grammarAccess.getXCatchClauseAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNumber
+entryRuleNumber
+@init {
+ HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+}
+:
+{ before(grammarAccess.getNumberRule()); }
+ ruleNumber
+{ after(grammarAccess.getNumberRule()); }
+ EOF
+;
+finally {
+ myHiddenTokenState.restore();
+}
+
+// Rule Number
+ruleNumber
+ @init {
+ HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getNumberAccess().getAlternatives()); }
+(rule__Number__Alternatives)
+{ after(grammarAccess.getNumberAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+ myHiddenTokenState.restore();
+}
+
+
+
+
+
+// Entry rule entryRuleJvmTypeReference
+entryRuleJvmTypeReference
+:
+{ before(grammarAccess.getJvmTypeReferenceRule()); }
+ ruleJvmTypeReference
+{ after(grammarAccess.getJvmTypeReferenceRule()); }
+ EOF
+;
+
+// Rule JvmTypeReference
+ruleJvmTypeReference
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); }
+(rule__JvmTypeReference__Alternatives)
+{ after(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleArrayBrackets
+entryRuleArrayBrackets
+:
+{ before(grammarAccess.getArrayBracketsRule()); }
+ ruleArrayBrackets
+{ after(grammarAccess.getArrayBracketsRule()); }
+ EOF
+;
+
+// Rule ArrayBrackets
+ruleArrayBrackets
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getArrayBracketsAccess().getGroup()); }
+(rule__ArrayBrackets__Group__0)
+{ after(grammarAccess.getArrayBracketsAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleXFunctionTypeRef
+entryRuleXFunctionTypeRef
+:
+{ before(grammarAccess.getXFunctionTypeRefRule()); }
+ ruleXFunctionTypeRef
+{ after(grammarAccess.getXFunctionTypeRefRule()); }
+ EOF
+;
+
+// Rule XFunctionTypeRef
+ruleXFunctionTypeRef
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXFunctionTypeRefAccess().getGroup()); }
+(rule__XFunctionTypeRef__Group__0)
+{ after(grammarAccess.getXFunctionTypeRefAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleJvmParameterizedTypeReference
+entryRuleJvmParameterizedTypeReference
+:
+{ before(grammarAccess.getJvmParameterizedTypeReferenceRule()); }
+ ruleJvmParameterizedTypeReference
+{ after(grammarAccess.getJvmParameterizedTypeReferenceRule()); }
+ EOF
+;
+
+// Rule JvmParameterizedTypeReference
+ruleJvmParameterizedTypeReference
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); }
+(rule__JvmParameterizedTypeReference__Group__0)
+{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleJvmArgumentTypeReference
+entryRuleJvmArgumentTypeReference
+:
+{ before(grammarAccess.getJvmArgumentTypeReferenceRule()); }
+ ruleJvmArgumentTypeReference
+{ after(grammarAccess.getJvmArgumentTypeReferenceRule()); }
+ EOF
+;
+
+// Rule JvmArgumentTypeReference
+ruleJvmArgumentTypeReference
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); }
+(rule__JvmArgumentTypeReference__Alternatives)
+{ after(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleJvmWildcardTypeReference
+entryRuleJvmWildcardTypeReference
+:
+{ before(grammarAccess.getJvmWildcardTypeReferenceRule()); }
+ ruleJvmWildcardTypeReference
+{ after(grammarAccess.getJvmWildcardTypeReferenceRule()); }
+ EOF
+;
+
+// Rule JvmWildcardTypeReference
+ruleJvmWildcardTypeReference
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); }
+(rule__JvmWildcardTypeReference__Group__0)
+{ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleJvmUpperBound
+entryRuleJvmUpperBound
+:
+{ before(grammarAccess.getJvmUpperBoundRule()); }
+ ruleJvmUpperBound
+{ after(grammarAccess.getJvmUpperBoundRule()); }
+ EOF
+;
+
+// Rule JvmUpperBound
+ruleJvmUpperBound
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getJvmUpperBoundAccess().getGroup()); }
+(rule__JvmUpperBound__Group__0)
+{ after(grammarAccess.getJvmUpperBoundAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleJvmUpperBoundAnded
+entryRuleJvmUpperBoundAnded
+:
+{ before(grammarAccess.getJvmUpperBoundAndedRule()); }
+ ruleJvmUpperBoundAnded
+{ after(grammarAccess.getJvmUpperBoundAndedRule()); }
+ EOF
+;
+
+// Rule JvmUpperBoundAnded
+ruleJvmUpperBoundAnded
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); }
+(rule__JvmUpperBoundAnded__Group__0)
+{ after(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleJvmLowerBound
+entryRuleJvmLowerBound
+:
+{ before(grammarAccess.getJvmLowerBoundRule()); }
+ ruleJvmLowerBound
+{ after(grammarAccess.getJvmLowerBoundRule()); }
+ EOF
+;
+
+// Rule JvmLowerBound
+ruleJvmLowerBound
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getJvmLowerBoundAccess().getGroup()); }
+(rule__JvmLowerBound__Group__0)
+{ after(grammarAccess.getJvmLowerBoundAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleJvmLowerBoundAnded
+entryRuleJvmLowerBoundAnded
+:
+{ before(grammarAccess.getJvmLowerBoundAndedRule()); }
+ ruleJvmLowerBoundAnded
+{ after(grammarAccess.getJvmLowerBoundAndedRule()); }
+ EOF
+;
+
+// Rule JvmLowerBoundAnded
+ruleJvmLowerBoundAnded
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); }
+(rule__JvmLowerBoundAnded__Group__0)
+{ after(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+// Entry rule entryRuleQualifiedNameWithWildcard
+entryRuleQualifiedNameWithWildcard
+:
+{ before(grammarAccess.getQualifiedNameWithWildcardRule()); }
+ ruleQualifiedNameWithWildcard
+{ after(grammarAccess.getQualifiedNameWithWildcardRule()); }
+ EOF
+;
+
+// Rule QualifiedNameWithWildcard
+ruleQualifiedNameWithWildcard
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); }
+(rule__QualifiedNameWithWildcard__Group__0)
+{ after(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+// Entry rule entryRuleXImportDeclaration
+entryRuleXImportDeclaration
+:
+{ before(grammarAccess.getXImportDeclarationRule()); }
+ ruleXImportDeclaration
+{ after(grammarAccess.getXImportDeclarationRule()); }
+ EOF
+;
+
+// Rule XImportDeclaration
+ruleXImportDeclaration
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getXImportDeclarationAccess().getGroup()); }
+(rule__XImportDeclaration__Group__0)
+{ after(grammarAccess.getXImportDeclarationAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleQualifiedNameInStaticImport
+entryRuleQualifiedNameInStaticImport
+:
+{ before(grammarAccess.getQualifiedNameInStaticImportRule()); }
+ ruleQualifiedNameInStaticImport
+{ after(grammarAccess.getQualifiedNameInStaticImportRule()); }
+ EOF
+;
+
+// Rule QualifiedNameInStaticImport
+ruleQualifiedNameInStaticImport
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+(
+{ before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
+(rule__QualifiedNameInStaticImport__Group__0)
+{ after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
+)
+(
+{ before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
+(rule__QualifiedNameInStaticImport__Group__0)*
+{ after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
+)
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+// Rule StyleCompare
+ruleStyleCompare
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getStyleCompareAccess().getAlternatives()); }
+(rule__StyleCompare__Alternatives)
+{ after(grammarAccess.getStyleCompareAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Rule TrendIconEnum
+ruleTrendIconEnum
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTrendIconEnumAccess().getAlternatives()); }
+(rule__TrendIconEnum__Alternatives)
+{ after(grammarAccess.getTrendIconEnumAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Rule RowHeaderMode
+ruleRowHeaderMode
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRowHeaderModeAccess().getAlternatives()); }
+(rule__RowHeaderMode__Alternatives)
+{ after(grammarAccess.getRowHeaderModeAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Rule AxisEnum
+ruleAxisEnum
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAxisEnumAccess().getAlternatives()); }
+(rule__AxisEnum__Alternatives)
+{ after(grammarAccess.getAxisEnumAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+rule__TableOption__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableOptionAccess().getTableSelectionParserRuleCall_0()); }
+ ruleTableSelection
+{ after(grammarAccess.getTableOptionAccess().getTableSelectionParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getTableOptionAccess().getTableTableParserRuleCall_1()); }
+ ruleTableTable
+{ after(grammarAccess.getTableOptionAccess().getTableTableParserRuleCall_1()); }
+)
+
+ |(
+{ before(grammarAccess.getTableOptionAccess().getTableGridParserRuleCall_2()); }
+ ruleTableGrid
+{ after(grammarAccess.getTableOptionAccess().getTableGridParserRuleCall_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getMultiSelectionAssignment_1_0()); }
+(rule__TableSelection__MultiSelectionAssignment_1_0)
+{ after(grammarAccess.getTableSelectionAccess().getMultiSelectionAssignment_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getTableSelectionAccess().getSingleselectionKeyword_1_1()); }
+
+ 'singleselection'
+
+{ after(grammarAccess.getTableSelectionAccess().getSingleselectionKeyword_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValueElement__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueElementAccess().getTableMeasureParserRuleCall_0()); }
+ ruleTableMeasure
+{ after(grammarAccess.getTableValueElementAccess().getTableMeasureParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getTableValueElementAccess().getTableDerivedParserRuleCall_1()); }
+ ruleTableDerived
+{ after(grammarAccess.getTableValueElementAccess().getTableDerivedParserRuleCall_1()); }
+)
+
+ |(
+{ before(grammarAccess.getTableValueElementAccess().getTableHierarchyParserRuleCall_2()); }
+ ruleTableHierarchy
+{ after(grammarAccess.getTableValueElementAccess().getTableHierarchyParserRuleCall_2()); }
+)
+
+ |(
+{ before(grammarAccess.getTableValueElementAccess().getTablePropertyParserRuleCall_3()); }
+ ruleTableProperty
+{ after(grammarAccess.getTableValueElementAccess().getTablePropertyParserRuleCall_3()); }
+)
+
+ |(
+{ before(grammarAccess.getTableValueElementAccess().getTableAggregationParserRuleCall_4()); }
+ ruleTableAggregation
+{ after(grammarAccess.getTableValueElementAccess().getTableAggregationParserRuleCall_4()); }
+)
+
+ |(
+{ before(grammarAccess.getTableValueElementAccess().getTableOrdinalParserRuleCall_5()); }
+ ruleTableOrdinal
+{ after(grammarAccess.getTableValueElementAccess().getTableOrdinalParserRuleCall_5()); }
+)
+
+ |(
+{ before(grammarAccess.getTableValueElementAccess().getTableColumnParserRuleCall_6()); }
+ ruleTableColumn
+{ after(grammarAccess.getTableValueElementAccess().getTableColumnParserRuleCall_6()); }
+)
+
+ |(
+{ before(grammarAccess.getTableValueElementAccess().getTableTaskParserRuleCall_7()); }
+ ruleTableTask
+{ after(grammarAccess.getTableValueElementAccess().getTableTaskParserRuleCall_7()); }
+)
+
+ |(
+{ before(grammarAccess.getTableValueElementAccess().getTableAllColumnsParserRuleCall_8()); }
+ ruleTableAllColumns
+{ after(grammarAccess.getTableValueElementAccess().getTableAllColumnsParserRuleCall_8()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableInterval__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableIntervalAccess().getTableNumberIntervalParserRuleCall_0()); }
+ ruleTableNumberInterval
+{ after(grammarAccess.getTableIntervalAccess().getTableNumberIntervalParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getTableIntervalAccess().getTableDateDayIntervalParserRuleCall_1()); }
+ ruleTableDateDayInterval
+{ after(grammarAccess.getTableIntervalAccess().getTableDateDayIntervalParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableLookup__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableLookupAccess().getTableNumberLookupParserRuleCall_0()); }
+ ruleTableNumberLookup
+{ after(grammarAccess.getTableLookupAccess().getTableNumberLookupParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getTableLookupAccess().getTableStringLookupParserRuleCall_1()); }
+ ruleTableStringLookup
+{ after(grammarAccess.getTableLookupAccess().getTableStringLookupParserRuleCall_1()); }
+)
+
+ |(
+{ before(grammarAccess.getTableLookupAccess().getTableDateDayLookupParserRuleCall_2()); }
+ ruleTableDateDayLookup
+{ after(grammarAccess.getTableLookupAccess().getTableDateDayLookupParserRuleCall_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableBrokerDatamart__Alternatives_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableBrokerDatamartAccess().getGroup_2_0()); }
+(rule__TableBrokerDatamart__Group_2_0__0)
+{ after(grammarAccess.getTableBrokerDatamartAccess().getGroup_2_0()); }
+)
+
+ |(
+{ before(grammarAccess.getTableBrokerDatamartAccess().getGroup_2_1()); }
+(rule__TableBrokerDatamart__Group_2_1__0)
+{ after(grammarAccess.getTableBrokerDatamartAccess().getGroup_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableRangeElement__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableRangeElementAccess().getTableTextColorParserRuleCall_0()); }
+ ruleTableTextColor
+{ after(grammarAccess.getTableRangeElementAccess().getTableTextColorParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getTableRangeElementAccess().getTableCellColorParserRuleCall_1()); }
+ ruleTableCellColor
+{ after(grammarAccess.getTableRangeElementAccess().getTableCellColorParserRuleCall_1()); }
+)
+
+ |(
+{ before(grammarAccess.getTableRangeElementAccess().getTableIconParserRuleCall_2()); }
+ ruleTableIcon
+{ after(grammarAccess.getTableRangeElementAccess().getTableIconParserRuleCall_2()); }
+)
+
+ |(
+{ before(grammarAccess.getTableRangeElementAccess().getTableTrendParserRuleCall_3()); }
+ ruleTableTrend
+{ after(grammarAccess.getTableRangeElementAccess().getTableTrendParserRuleCall_3()); }
+)
+
+ |(
+{ before(grammarAccess.getTableRangeElementAccess().getTableTooltipParserRuleCall_4()); }
+ ruleTableTooltip
+{ after(grammarAccess.getTableRangeElementAccess().getTableTooltipParserRuleCall_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PropertyStyle__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyButtonStyleParserRuleCall_0()); }
+ rulePropertyButtonStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyButtonStyleParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyHtmlStyleParserRuleCall_1()); }
+ rulePropertyHtmlStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyHtmlStyleParserRuleCall_1()); }
+)
+
+ |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyProgressbarStyleParserRuleCall_2()); }
+ rulePropertyProgressbarStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyProgressbarStyleParserRuleCall_2()); }
+)
+
+ |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyTextStyleParserRuleCall_3()); }
+ rulePropertyTextStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyTextStyleParserRuleCall_3()); }
+)
+
+ |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyBooleanStyleParserRuleCall_4()); }
+ rulePropertyBooleanStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyBooleanStyleParserRuleCall_4()); }
+)
+
+ |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyDateStyleParserRuleCall_5()); }
+ rulePropertyDateStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyDateStyleParserRuleCall_5()); }
+)
+
+ |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyNumberStyleParserRuleCall_6()); }
+ rulePropertyNumberStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyNumberStyleParserRuleCall_6()); }
+)
+
+ |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyImageStyleParserRuleCall_7()); }
+ rulePropertyImageStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyImageStyleParserRuleCall_7()); }
+)
+
+ |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyQuantityStyleParserRuleCall_8()); }
+ rulePropertyQuantityStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyQuantityStyleParserRuleCall_8()); }
+)
+
+ |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyPriceStyleParserRuleCall_9()); }
+ rulePropertyPriceStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyPriceStyleParserRuleCall_9()); }
+)
+
+ |(
+{ before(grammarAccess.getPropertyStyleAccess().getGridPropIndicatorStyleParserRuleCall_10()); }
+ ruleGridPropIndicatorStyle
+{ after(grammarAccess.getPropertyStyleAccess().getGridPropIndicatorStyleParserRuleCall_10()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__StyleConfig__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getStyleConfigAccess().getNumericToResourceStyleConfigParserRuleCall_0()); }
+ ruleNumericToResourceStyleConfig
+{ after(grammarAccess.getStyleConfigAccess().getNumericToResourceStyleConfigParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getStyleConfigAccess().getStringToResourceStyleConfigParserRuleCall_1()); }
+ ruleStringToResourceStyleConfig
+{ after(grammarAccess.getStyleConfigAccess().getStringToResourceStyleConfigParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LInt__Alternatives_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLIntAccess().getPlusSignKeyword_0_0()); }
+
+ '+'
+
+{ after(grammarAccess.getLIntAccess().getPlusSignKeyword_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getLIntAccess().getHyphenMinusKeyword_0_1()); }
+
+ '-'
+
+{ after(grammarAccess.getLIntAccess().getHyphenMinusKeyword_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Alternatives_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXAnnotationAccess().getGroup_3_1_0()); }
+(rule__XAnnotation__Group_3_1_0__0)
+{ after(grammarAccess.getXAnnotationAccess().getGroup_3_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXAnnotationAccess().getValueAssignment_3_1_1()); }
+(rule__XAnnotation__ValueAssignment_3_1_1)
+{ after(grammarAccess.getXAnnotationAccess().getValueAssignment_3_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0()); }
+(rule__XAnnotationElementValueOrCommaList__Group_0__0)
+{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1()); }
+(rule__XAnnotationElementValueOrCommaList__Group_1__0)
+{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0()); }
+(rule__XAnnotationElementValue__Group_0__0)
+{ after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1()); }
+ ruleXAnnotationOrExpression
+{ after(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAnnotationOrExpression__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0()); }
+ ruleXAnnotation
+{ after(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1()); }
+ ruleXExpression
+{ after(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXAssignmentAccess().getGroup_0()); }
+(rule__XAssignment__Group_0__0)
+{ after(grammarAccess.getXAssignmentAccess().getGroup_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXAssignmentAccess().getGroup_1()); }
+(rule__XAssignment__Group_1__0)
+{ after(grammarAccess.getXAssignmentAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); }
+
+ '+='
+
+{ after(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); }
+)
+
+ |(
+{ before(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); }
+
+ '-='
+
+{ after(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); }
+)
+
+ |(
+{ before(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); }
+
+ '*='
+
+{ after(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); }
+)
+
+ |(
+{ before(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); }
+
+ '/='
+
+{ after(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); }
+)
+
+ |(
+{ before(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); }
+
+ '%='
+
+{ after(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); }
+)
+
+ |(
+{ before(grammarAccess.getOpMultiAssignAccess().getGroup_5()); }
+(rule__OpMultiAssign__Group_5__0)
+{ after(grammarAccess.getOpMultiAssignAccess().getGroup_5()); }
+)
+
+ |(
+{ before(grammarAccess.getOpMultiAssignAccess().getGroup_6()); }
+(rule__OpMultiAssign__Group_6__0)
+{ after(grammarAccess.getOpMultiAssignAccess().getGroup_6()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpEquality__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); }
+
+ '=='
+
+{ after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); }
+)
+
+ |(
+{ before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); }
+
+ '!='
+
+{ after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); }
+)
+
+ |(
+{ before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); }
+
+ '==='
+
+{ after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); }
+)
+
+ |(
+{ before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); }
+
+ '!=='
+
+{ after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); }
+(rule__XRelationalExpression__Group_1_0__0)
+{ after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); }
+(rule__XRelationalExpression__Group_1_1__0)
+{ after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpCompare__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); }
+
+ '>='
+
+{ after(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); }
+)
+
+ |(
+{ before(grammarAccess.getOpCompareAccess().getGroup_1()); }
+(rule__OpCompare__Group_1__0)
+{ after(grammarAccess.getOpCompareAccess().getGroup_1()); }
+)
+
+ |(
+{ before(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); }
+
+ '>'
+
+{ after(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); }
+)
+
+ |(
+{ before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); }
+
+ '<'
+
+{ after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+
+ '->'
+
+{ after(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+)
+
+ |(
+{ before(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); }
+
+ '..<'
+
+{ after(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); }
+)
+
+ |(
+{ before(grammarAccess.getOpOtherAccess().getGroup_2()); }
+(rule__OpOther__Group_2__0)
+{ after(grammarAccess.getOpOtherAccess().getGroup_2()); }
+)
+
+ |(
+{ before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); }
+
+ '..'
+
+{ after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); }
+)
+
+ |(
+{ before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); }
+
+ '=>'
+
+{ after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); }
+)
+
+ |(
+{ before(grammarAccess.getOpOtherAccess().getGroup_5()); }
+(rule__OpOther__Group_5__0)
+{ after(grammarAccess.getOpOtherAccess().getGroup_5()); }
+)
+
+ |(
+{ before(grammarAccess.getOpOtherAccess().getGroup_6()); }
+(rule__OpOther__Group_6__0)
+{ after(grammarAccess.getOpOtherAccess().getGroup_6()); }
+)
+
+ |(
+{ before(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); }
+
+ '<>'
+
+{ after(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); }
+)
+
+ |(
+{ before(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); }
+
+ '?:'
+
+{ after(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Alternatives_5_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); }
+(rule__OpOther__Group_5_1_0__0)
+{ after(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); }
+
+ '>'
+
+{ after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpOther__Alternatives_6_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); }
+(rule__OpOther__Group_6_1_0__0)
+{ after(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); }
+
+ '<'
+
+{ after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); }
+)
+
+ |(
+{ before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); }
+
+ '=>'
+
+{ after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpAdd__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); }
+
+ '+'
+
+{ after(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); }
+)
+
+ |(
+{ before(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); }
+
+ '-'
+
+{ after(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpMulti__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); }
+
+ '*'
+
+{ after(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); }
+)
+
+ |(
+{ before(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); }
+
+ '**'
+
+{ after(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); }
+)
+
+ |(
+{ before(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); }
+
+ '/'
+
+{ after(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); }
+)
+
+ |(
+{ before(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); }
+
+ '%'
+
+{ after(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XUnaryOperation__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXUnaryOperationAccess().getGroup_0()); }
+(rule__XUnaryOperation__Group_0__0)
+{ after(grammarAccess.getXUnaryOperationAccess().getGroup_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); }
+ ruleXCastedExpression
+{ after(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpUnary__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); }
+
+ '!'
+
+{ after(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); }
+)
+
+ |(
+{ before(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); }
+
+ '-'
+
+{ after(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); }
+)
+
+ |(
+{ before(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); }
+
+ '+'
+
+{ after(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__OpPostfix__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); }
+
+ '++'
+
+{ after(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); }
+)
+
+ |(
+{ before(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); }
+
+ '--'
+
+{ after(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); }
+(rule__XMemberFeatureCall__Group_1_0__0)
+{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); }
+(rule__XMemberFeatureCall__Group_1_1__0)
+{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Alternatives_1_0_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); }
+
+ '.'
+
+{ after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); }
+(rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1)
+{ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Alternatives_1_1_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); }
+
+ '.'
+
+{ after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); }
+(rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1)
+{ after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); }
+)
+
+ |(
+{ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); }
+(rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2)
+{ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Alternatives_1_1_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); }
+(rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0)
+{ after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); }
+(rule__XMemberFeatureCall__Group_1_1_3_1_1__0)
+{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XPrimaryExpression__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); }
+ ruleXConstructorCall
+{ after(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); }
+ ruleXBlockExpression
+{ after(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); }
+)
+
+ |(
+{ before(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); }
+ ruleXSwitchExpression
+{ after(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); }
+)
+
+ |(
+{ before(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); }
+( ruleXSynchronizedExpression)
+{ after(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); }
+)
+
+ |(
+{ before(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); }
+ ruleXFeatureCall
+{ after(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); }
+)
+
+ |(
+{ before(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); }
+ ruleXLiteral
+{ after(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); }
+)
+
+ |(
+{ before(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); }
+ ruleXIfExpression
+{ after(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); }
+)
+
+ |(
+{ before(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); }
+( ruleXForLoopExpression)
+{ after(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); }
+)
+
+ |(
+{ before(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); }
+ ruleXBasicForLoopExpression
+{ after(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); }
+)
+
+ |(
+{ before(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); }
+ ruleXWhileExpression
+{ after(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); }
+)
+
+ |(
+{ before(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); }
+ ruleXDoWhileExpression
+{ after(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); }
+)
+
+ |(
+{ before(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); }
+ ruleXThrowExpression
+{ after(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); }
+)
+
+ |(
+{ before(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); }
+ ruleXReturnExpression
+{ after(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); }
+)
+
+ |(
+{ before(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); }
+ ruleXTryCatchFinallyExpression
+{ after(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); }
+)
+
+ |(
+{ before(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); }
+ ruleXParenthesizedExpression
+{ after(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XLiteral__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); }
+ ruleXCollectionLiteral
+{ after(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); }
+( ruleXClosure)
+{ after(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); }
+)
+
+ |(
+{ before(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); }
+ ruleXBooleanLiteral
+{ after(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); }
+)
+
+ |(
+{ before(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); }
+ ruleXNumberLiteral
+{ after(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); }
+)
+
+ |(
+{ before(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); }
+ ruleXNullLiteral
+{ after(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); }
+)
+
+ |(
+{ before(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); }
+ ruleXStringLiteral
+{ after(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); }
+)
+
+ |(
+{ before(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); }
+ ruleXTypeLiteral
+{ after(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCollectionLiteral__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); }
+ ruleXSetLiteral
+{ after(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); }
+ ruleXListLiteral
+{ after(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Alternatives_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); }
+(rule__XSwitchExpression__Group_2_0__0)
+{ after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); }
+(rule__XSwitchExpression__Group_2_1__0)
+{ after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Alternatives_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXCasePartAccess().getGroup_3_0()); }
+(rule__XCasePart__Group_3_0__0)
+{ after(grammarAccess.getXCasePartAccess().getGroup_3_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); }
+(rule__XCasePart__FallThroughAssignment_3_1)
+{ after(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XExpressionOrVarDeclaration__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); }
+ ruleXVariableDeclaration
+{ after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); }
+ ruleXExpression
+{ after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); }
+(rule__XVariableDeclaration__WriteableAssignment_1_0)
+{ after(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); }
+
+ 'val'
+
+{ after(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Alternatives_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); }
+(rule__XVariableDeclaration__Group_2_0__0)
+{ after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); }
+(rule__XVariableDeclaration__NameAssignment_2_1)
+{ after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Alternatives_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); }
+(rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0)
+{ after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); }
+(rule__XFeatureCall__Group_3_1_1__0)
+{ after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__FeatureCallID__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); }
+ ruleValidID
+{ after(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); }
+
+ 'extends'
+
+{ after(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); }
+)
+
+ |(
+{ before(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); }
+
+ 'static'
+
+{ after(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); }
+)
+
+ |(
+{ before(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); }
+
+ 'import'
+
+{ after(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); }
+)
+
+ |(
+{ before(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); }
+
+ 'extension'
+
+{ after(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IdOrSuper__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); }
+ ruleFeatureCallID
+{ after(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); }
+
+ 'super'
+
+{ after(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Alternatives_4_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); }
+(rule__XConstructorCall__ArgumentsAssignment_4_1_0)
+{ after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); }
+(rule__XConstructorCall__Group_4_1_1__0)
+{ after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XBooleanLiteral__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); }
+
+ 'false'
+
+{ after(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); }
+(rule__XBooleanLiteral__IsTrueAssignment_1_1)
+{ after(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Alternatives_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); }
+(rule__XTryCatchFinallyExpression__Group_3_0__0)
+{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); }
+(rule__XTryCatchFinallyExpression__Group_3_1__0)
+{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Number__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); }
+ RULE_HEX
+{ after(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getNumberAccess().getGroup_1()); }
+(rule__Number__Group_1__0)
+{ after(grammarAccess.getNumberAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Number__Alternatives_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); }
+ RULE_INT
+{ after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); }
+ RULE_DECIMAL
+{ after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Number__Alternatives_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); }
+ RULE_INT
+{ after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); }
+ RULE_DECIMAL
+{ after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmTypeReference__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); }
+(rule__JvmTypeReference__Group_0__0)
+{ after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); }
+)
+
+ |(
+{ before(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); }
+ ruleXFunctionTypeRef
+{ after(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmArgumentTypeReference__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); }
+ ruleJvmTypeReference
+{ after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); }
+ ruleJvmWildcardTypeReference
+{ after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Alternatives_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); }
+(rule__JvmWildcardTypeReference__Group_2_0__0)
+{ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); }
+)
+
+ |(
+{ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); }
+(rule__JvmWildcardTypeReference__Group_2_1__0)
+{ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); }
+(rule__XImportDeclaration__Group_1_0__0)
+{ after(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); }
+(rule__XImportDeclaration__ImportedTypeAssignment_1_1)
+{ after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); }
+)
+
+ |(
+{ before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); }
+(rule__XImportDeclaration__ImportedNamespaceAssignment_1_2)
+{ after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Alternatives_1_0_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); }
+(rule__XImportDeclaration__WildcardAssignment_1_0_3_0)
+{ after(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); }
+)
+
+ |(
+{ before(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); }
+(rule__XImportDeclaration__MemberNameAssignment_1_0_3_1)
+{ after(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__StyleCompare__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getStyleCompareAccess().getEqualEnumLiteralDeclaration_0()); }
+( 'equal'
+)
+{ after(grammarAccess.getStyleCompareAccess().getEqualEnumLiteralDeclaration_0()); }
+)
+
+ |(
+{ before(grammarAccess.getStyleCompareAccess().getGreaterEqualEnumLiteralDeclaration_1()); }
+( 'greater equal'
+)
+{ after(grammarAccess.getStyleCompareAccess().getGreaterEqualEnumLiteralDeclaration_1()); }
+)
+
+ |(
+{ before(grammarAccess.getStyleCompareAccess().getGreaterThanEnumLiteralDeclaration_2()); }
+( 'greater than'
+)
+{ after(grammarAccess.getStyleCompareAccess().getGreaterThanEnumLiteralDeclaration_2()); }
+)
+
+ |(
+{ before(grammarAccess.getStyleCompareAccess().getLowerEqualEnumLiteralDeclaration_3()); }
+( 'lower equal'
+)
+{ after(grammarAccess.getStyleCompareAccess().getLowerEqualEnumLiteralDeclaration_3()); }
+)
+
+ |(
+{ before(grammarAccess.getStyleCompareAccess().getLowerThanEnumLiteralDeclaration_4()); }
+( 'lower than'
+)
+{ after(grammarAccess.getStyleCompareAccess().getLowerThanEnumLiteralDeclaration_4()); }
+)
+
+ |(
+{ before(grammarAccess.getStyleCompareAccess().getNotEqualEnumLiteralDeclaration_5()); }
+( 'not equal'
+)
+{ after(grammarAccess.getStyleCompareAccess().getNotEqualEnumLiteralDeclaration_5()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TrendIconEnum__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTrendIconEnumAccess().getRISINGEnumLiteralDeclaration_0()); }
+( 'rising'
+)
+{ after(grammarAccess.getTrendIconEnumAccess().getRISINGEnumLiteralDeclaration_0()); }
+)
+
+ |(
+{ before(grammarAccess.getTrendIconEnumAccess().getBADRISINGEnumLiteralDeclaration_1()); }
+( 'bad-rising'
+)
+{ after(grammarAccess.getTrendIconEnumAccess().getBADRISINGEnumLiteralDeclaration_1()); }
+)
+
+ |(
+{ before(grammarAccess.getTrendIconEnumAccess().getSLOPINGEnumLiteralDeclaration_2()); }
+( 'sloping'
+)
+{ after(grammarAccess.getTrendIconEnumAccess().getSLOPINGEnumLiteralDeclaration_2()); }
+)
+
+ |(
+{ before(grammarAccess.getTrendIconEnumAccess().getGOODSLOPINGEnumLiteralDeclaration_3()); }
+( 'good-sloping'
+)
+{ after(grammarAccess.getTrendIconEnumAccess().getGOODSLOPINGEnumLiteralDeclaration_3()); }
+)
+
+ |(
+{ before(grammarAccess.getTrendIconEnumAccess().getSTAGNATINGEnumLiteralDeclaration_4()); }
+( 'stagnating'
+)
+{ after(grammarAccess.getTrendIconEnumAccess().getSTAGNATINGEnumLiteralDeclaration_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RowHeaderMode__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRowHeaderModeAccess().getHIDDENEnumLiteralDeclaration_0()); }
+( 'hidden'
+)
+{ after(grammarAccess.getRowHeaderModeAccess().getHIDDENEnumLiteralDeclaration_0()); }
+)
+
+ |(
+{ before(grammarAccess.getRowHeaderModeAccess().getEXPLICIT_DEFAULTS_IDEnumLiteralDeclaration_1()); }
+( 'explicit'
+)
+{ after(grammarAccess.getRowHeaderModeAccess().getEXPLICIT_DEFAULTS_IDEnumLiteralDeclaration_1()); }
+)
+
+ |(
+{ before(grammarAccess.getRowHeaderModeAccess().getINDEXEnumLiteralDeclaration_2()); }
+( 'indexed'
+)
+{ after(grammarAccess.getRowHeaderModeAccess().getINDEXEnumLiteralDeclaration_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AxisEnum__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAxisEnumAccess().getDEFAULTEnumLiteralDeclaration_0()); }
+( 'default'
+)
+{ after(grammarAccess.getAxisEnumAccess().getDEFAULTEnumLiteralDeclaration_0()); }
+)
+
+ |(
+{ before(grammarAccess.getAxisEnumAccess().getCOLUMNSEnumLiteralDeclaration_1()); }
+( 'columns'
+)
+{ after(grammarAccess.getAxisEnumAccess().getCOLUMNSEnumLiteralDeclaration_1()); }
+)
+
+ |(
+{ before(grammarAccess.getAxisEnumAccess().getROWSEnumLiteralDeclaration_2()); }
+( 'rows'
+)
+{ after(grammarAccess.getAxisEnumAccess().getROWSEnumLiteralDeclaration_2()); }
+)
+
+ |(
+{ before(grammarAccess.getAxisEnumAccess().getPAGESEnumLiteralDeclaration_3()); }
+( 'pages'
+)
+{ after(grammarAccess.getAxisEnumAccess().getPAGESEnumLiteralDeclaration_3()); }
+)
+
+ |(
+{ before(grammarAccess.getAxisEnumAccess().getSECTIONSEnumLiteralDeclaration_4()); }
+( 'sections'
+)
+{ after(grammarAccess.getAxisEnumAccess().getSECTIONSEnumLiteralDeclaration_4()); }
+)
+
+ |(
+{ before(grammarAccess.getAxisEnumAccess().getCHAPTERSEnumLiteralDeclaration_5()); }
+( 'chapters'
+)
+{ after(grammarAccess.getAxisEnumAccess().getCHAPTERSEnumLiteralDeclaration_5()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+rule__TablePackage__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TablePackage__Group__0__Impl
+ rule__TablePackage__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TablePackage__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTablePackageAccess().getTablePackageAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTablePackageAccess().getTablePackageAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TablePackage__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TablePackage__Group__1__Impl
+ rule__TablePackage__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TablePackage__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTablePackageAccess().getPackageKeyword_1()); }
+
+ 'package'
+
+{ after(grammarAccess.getTablePackageAccess().getPackageKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TablePackage__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TablePackage__Group__2__Impl
+ rule__TablePackage__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TablePackage__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTablePackageAccess().getNameAssignment_2()); }
+(rule__TablePackage__NameAssignment_2)
+{ after(grammarAccess.getTablePackageAccess().getNameAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TablePackage__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TablePackage__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TablePackage__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTablePackageAccess().getGroup_3()); }
+(rule__TablePackage__Group_3__0)?
+{ after(grammarAccess.getTablePackageAccess().getGroup_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TablePackage__Group_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TablePackage__Group_3__0__Impl
+ rule__TablePackage__Group_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TablePackage__Group_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTablePackageAccess().getLeftCurlyBracketKeyword_3_0()); }
+
+ '{'
+
+{ after(grammarAccess.getTablePackageAccess().getLeftCurlyBracketKeyword_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TablePackage__Group_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TablePackage__Group_3__1__Impl
+ rule__TablePackage__Group_3__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TablePackage__Group_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTablePackageAccess().getImportsAssignment_3_1()); }
+(rule__TablePackage__ImportsAssignment_3_1)*
+{ after(grammarAccess.getTablePackageAccess().getImportsAssignment_3_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TablePackage__Group_3__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TablePackage__Group_3__2__Impl
+ rule__TablePackage__Group_3__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TablePackage__Group_3__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTablePackageAccess().getTablesAssignment_3_2()); }
+(rule__TablePackage__TablesAssignment_3_2)*
+{ after(grammarAccess.getTablePackageAccess().getTablesAssignment_3_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TablePackage__Group_3__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TablePackage__Group_3__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TablePackage__Group_3__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTablePackageAccess().getRightCurlyBracketKeyword_3_3()); }
+
+ '}'
+
+{ after(grammarAccess.getTablePackageAccess().getRightCurlyBracketKeyword_3_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__Table__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Table__Group__0__Impl
+ rule__Table__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Table__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableAccess().getTableAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableAccess().getTableAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Table__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Table__Group__1__Impl
+ rule__Table__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Table__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableAccess().getTableKeyword_1()); }
+
+ 'table'
+
+{ after(grammarAccess.getTableAccess().getTableKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Table__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Table__Group__2__Impl
+ rule__Table__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Table__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableAccess().getNameAssignment_2()); }
+(rule__Table__NameAssignment_2)
+{ after(grammarAccess.getTableAccess().getNameAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Table__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Table__Group__3__Impl
+ rule__Table__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Table__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableAccess().getGroup_3()); }
+(rule__Table__Group_3__0)?
+{ after(grammarAccess.getTableAccess().getGroup_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Table__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Table__Group__4__Impl
+ rule__Table__Group__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Table__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableAccess().getAsKeyword_4()); }
+
+ 'as'
+
+{ after(grammarAccess.getTableAccess().getAsKeyword_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Table__Group__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Table__Group__5__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Table__Group__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableAccess().getTabletypeAssignment_5()); }
+(rule__Table__TabletypeAssignment_5)
+{ after(grammarAccess.getTableAccess().getTabletypeAssignment_5()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__Table__Group_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Table__Group_3__0__Impl
+ rule__Table__Group_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Table__Group_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableAccess().getDescriptionAssignment_3_0()); }
+(rule__Table__DescriptionAssignment_3_0)
+{ after(grammarAccess.getTableAccess().getDescriptionAssignment_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Table__Group_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Table__Group_3__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Table__Group_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableAccess().getDescriptionValueAssignment_3_1()); }
+(rule__Table__DescriptionValueAssignment_3_1)
+{ after(grammarAccess.getTableAccess().getDescriptionValueAssignment_3_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableSelection__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableSelection__Group__0__Impl
+ rule__TableSelection__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getTableSelectionAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableSelectionAccess().getTableSelectionAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableSelection__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableSelection__Group__1__Impl
+ rule__TableSelection__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getAlternatives_1()); }
+(rule__TableSelection__Alternatives_1)
+{ after(grammarAccess.getTableSelectionAccess().getAlternatives_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableSelection__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableSelection__Group__2__Impl
+ rule__TableSelection__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getUnorderedGroup_2()); }
+(rule__TableSelection__UnorderedGroup_2)
+{ after(grammarAccess.getTableSelectionAccess().getUnorderedGroup_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableSelection__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableSelection__Group__3__Impl
+ rule__TableSelection__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3()); }
+(rule__TableSelection__UnorderedGroup_3)
+{ after(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableSelection__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableSelection__Group__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getGroup_4()); }
+(rule__TableSelection__Group_4__0)?
+{ after(grammarAccess.getTableSelectionAccess().getGroup_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__TableSelection__Group_2_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableSelection__Group_2_1__0__Impl
+ rule__TableSelection__Group_2_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group_2_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getRowheaderKeyword_2_1_0()); }
+
+ 'rowheader'
+
+{ after(grammarAccess.getTableSelectionAccess().getRowheaderKeyword_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableSelection__Group_2_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableSelection__Group_2_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group_2_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getHeaderModeAssignment_2_1_1()); }
+(rule__TableSelection__HeaderModeAssignment_2_1_1)
+{ after(grammarAccess.getTableSelectionAccess().getHeaderModeAssignment_2_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableSelection__Group_3_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableSelection__Group_3_0__0__Impl
+ rule__TableSelection__Group_3_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group_3_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getPollingAssignment_3_0_0()); }
+(rule__TableSelection__PollingAssignment_3_0_0)
+{ after(grammarAccess.getTableSelectionAccess().getPollingAssignment_3_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableSelection__Group_3_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableSelection__Group_3_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group_3_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getPollingTimeAssignment_3_0_1()); }
+(rule__TableSelection__PollingTimeAssignment_3_0_1)
+{ after(grammarAccess.getTableSelectionAccess().getPollingTimeAssignment_3_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableSelection__Group_3_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableSelection__Group_3_3__0__Impl
+ rule__TableSelection__Group_3_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group_3_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getToolbarKeyword_3_3_0()); }
+
+ 'toolbar'
+
+{ after(grammarAccess.getTableSelectionAccess().getToolbarKeyword_3_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableSelection__Group_3_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableSelection__Group_3_3__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group_3_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getToolbarAssignment_3_3_1()); }
+(rule__TableSelection__ToolbarAssignment_3_3_1)
+{ after(grammarAccess.getTableSelectionAccess().getToolbarAssignment_3_3_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableSelection__Group_4__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableSelection__Group_4__0__Impl
+ rule__TableSelection__Group_4__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group_4__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getUsingKeyword_4_0()); }
+
+ 'using'
+
+{ after(grammarAccess.getTableSelectionAccess().getUsingKeyword_4_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableSelection__Group_4__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableSelection__Group_4__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group_4__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getSourceAssignment_4_1()); }
+(rule__TableSelection__SourceAssignment_4_1)
+{ after(grammarAccess.getTableSelectionAccess().getSourceAssignment_4_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableTable__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTable__Group__0__Impl
+ rule__TableTable__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getTableTableAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableTableAccess().getTableTableAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableTable__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTable__Group__1__Impl
+ rule__TableTable__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getTableKeyword_1()); }
+
+ 'table'
+
+{ after(grammarAccess.getTableTableAccess().getTableKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableTable__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTable__Group__2__Impl
+ rule__TableTable__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getUnorderedGroup_2()); }
+(rule__TableTable__UnorderedGroup_2)
+{ after(grammarAccess.getTableTableAccess().getUnorderedGroup_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableTable__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTable__Group__3__Impl
+ rule__TableTable__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getUnorderedGroup_3()); }
+(rule__TableTable__UnorderedGroup_3)
+{ after(grammarAccess.getTableTableAccess().getUnorderedGroup_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableTable__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTable__Group__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getGroup_4()); }
+(rule__TableTable__Group_4__0)?
+{ after(grammarAccess.getTableTableAccess().getGroup_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__TableTable__Group_2_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTable__Group_2_1__0__Impl
+ rule__TableTable__Group_2_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group_2_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getRowheaderKeyword_2_1_0()); }
+
+ 'rowheader'
+
+{ after(grammarAccess.getTableTableAccess().getRowheaderKeyword_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableTable__Group_2_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTable__Group_2_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group_2_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getHeaderModeAssignment_2_1_1()); }
+(rule__TableTable__HeaderModeAssignment_2_1_1)
+{ after(grammarAccess.getTableTableAccess().getHeaderModeAssignment_2_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableTable__Group_3_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTable__Group_3_0__0__Impl
+ rule__TableTable__Group_3_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group_3_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getPollingAssignment_3_0_0()); }
+(rule__TableTable__PollingAssignment_3_0_0)
+{ after(grammarAccess.getTableTableAccess().getPollingAssignment_3_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableTable__Group_3_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTable__Group_3_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group_3_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getPollingTimeAssignment_3_0_1()); }
+(rule__TableTable__PollingTimeAssignment_3_0_1)
+{ after(grammarAccess.getTableTableAccess().getPollingTimeAssignment_3_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableTable__Group_3_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTable__Group_3_3__0__Impl
+ rule__TableTable__Group_3_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group_3_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getToolbarKeyword_3_3_0()); }
+
+ 'toolbar'
+
+{ after(grammarAccess.getTableTableAccess().getToolbarKeyword_3_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableTable__Group_3_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTable__Group_3_3__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group_3_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getToolbarAssignment_3_3_1()); }
+(rule__TableTable__ToolbarAssignment_3_3_1)
+{ after(grammarAccess.getTableTableAccess().getToolbarAssignment_3_3_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableTable__Group_4__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTable__Group_4__0__Impl
+ rule__TableTable__Group_4__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group_4__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getUsingKeyword_4_0()); }
+
+ 'using'
+
+{ after(grammarAccess.getTableTableAccess().getUsingKeyword_4_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableTable__Group_4__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTable__Group_4__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group_4__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getSourceAssignment_4_1()); }
+(rule__TableTable__SourceAssignment_4_1)
+{ after(grammarAccess.getTableTableAccess().getSourceAssignment_4_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TablePreorder__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TablePreorder__Group__0__Impl
+ rule__TablePreorder__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TablePreorder__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTablePreorderAccess().getTablePreorderAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTablePreorderAccess().getTablePreorderAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TablePreorder__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TablePreorder__Group__1__Impl
+ rule__TablePreorder__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TablePreorder__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTablePreorderAccess().getPreorderKeyword_1()); }
+
+ 'preorder'
+
+{ after(grammarAccess.getTablePreorderAccess().getPreorderKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TablePreorder__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TablePreorder__Group__2__Impl
+ rule__TablePreorder__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TablePreorder__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTablePreorderAccess().getColumnAssignment_2()); }
+(rule__TablePreorder__ColumnAssignment_2)
+{ after(grammarAccess.getTablePreorderAccess().getColumnAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TablePreorder__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TablePreorder__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TablePreorder__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTablePreorderAccess().getAscendingAssignment_3()); }
+(rule__TablePreorder__AscendingAssignment_3)?
+{ after(grammarAccess.getTablePreorderAccess().getAscendingAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TableValue__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group__0__Impl
+ rule__TableValue__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getTableValueAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableValueAccess().getTableValueAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group__1__Impl
+ rule__TableValue__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getValueKeyword_1()); }
+
+ 'value'
+
+{ after(grammarAccess.getTableValueAccess().getValueKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group__2__Impl
+ rule__TableValue__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getColumnAssignment_2()); }
+(rule__TableValue__ColumnAssignment_2)
+{ after(grammarAccess.getTableValueAccess().getColumnAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group__3__Impl
+ rule__TableValue__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getUnorderedGroup_3()); }
+(rule__TableValue__UnorderedGroup_3)
+{ after(grammarAccess.getTableValueAccess().getUnorderedGroup_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getUnorderedGroup_4()); }
+(rule__TableValue__UnorderedGroup_4)
+{ after(grammarAccess.getTableValueAccess().getUnorderedGroup_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__TableValue__Group_3_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group_3_1__0__Impl
+ rule__TableValue__Group_3_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_3_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getIconKeyword_3_1_0()); }
+
+ 'icon'
+
+{ after(grammarAccess.getTableValueAccess().getIconKeyword_3_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_3_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group_3_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_3_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getIconNameAssignment_3_1_1()); }
+(rule__TableValue__IconNameAssignment_3_1_1)
+{ after(grammarAccess.getTableValueAccess().getIconNameAssignment_3_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableValue__Group_3_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group_3_3__0__Impl
+ rule__TableValue__Group_3_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_3_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getHasImageAssignment_3_3_0()); }
+(rule__TableValue__HasImageAssignment_3_3_0)
+{ after(grammarAccess.getTableValueAccess().getHasImageAssignment_3_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_3_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group_3_3__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_3_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getImageAssignment_3_3_1()); }
+(rule__TableValue__ImageAssignment_3_3_1)
+{ after(grammarAccess.getTableValueAccess().getImageAssignment_3_3_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableValue__Group_4_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group_4_0__0__Impl
+ rule__TableValue__Group_4_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getIntervalsKeyword_4_0_0()); }
+
+ 'intervals'
+
+{ after(grammarAccess.getTableValueAccess().getIntervalsKeyword_4_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_4_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group_4_0__1__Impl
+ rule__TableValue__Group_4_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getHideLabelIntervalAssignment_4_0_1()); }
+(rule__TableValue__HideLabelIntervalAssignment_4_0_1)?
+{ after(grammarAccess.getTableValueAccess().getHideLabelIntervalAssignment_4_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_4_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group_4_0__2__Impl
+ rule__TableValue__Group_4_0__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getLeftCurlyBracketKeyword_4_0_2()); }
+
+ '{'
+
+{ after(grammarAccess.getTableValueAccess().getLeftCurlyBracketKeyword_4_0_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_4_0__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group_4_0__3__Impl
+ rule__TableValue__Group_4_0__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_0__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getIntervalsAssignment_4_0_3()); }
+(rule__TableValue__IntervalsAssignment_4_0_3)*
+{ after(grammarAccess.getTableValueAccess().getIntervalsAssignment_4_0_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_4_0__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group_4_0__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_0__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getRightCurlyBracketKeyword_4_0_4()); }
+
+ '}'
+
+{ after(grammarAccess.getTableValueAccess().getRightCurlyBracketKeyword_4_0_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__TableValue__Group_4_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group_4_1__0__Impl
+ rule__TableValue__Group_4_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getLookupsKeyword_4_1_0()); }
+
+ 'lookups'
+
+{ after(grammarAccess.getTableValueAccess().getLookupsKeyword_4_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_4_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group_4_1__1__Impl
+ rule__TableValue__Group_4_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getHideLabelLookupAssignment_4_1_1()); }
+(rule__TableValue__HideLabelLookupAssignment_4_1_1)?
+{ after(grammarAccess.getTableValueAccess().getHideLabelLookupAssignment_4_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_4_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group_4_1__2__Impl
+ rule__TableValue__Group_4_1__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getLeftCurlyBracketKeyword_4_1_2()); }
+
+ '{'
+
+{ after(grammarAccess.getTableValueAccess().getLeftCurlyBracketKeyword_4_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_4_1__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group_4_1__3__Impl
+ rule__TableValue__Group_4_1__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_1__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getLookupsAssignment_4_1_3()); }
+(rule__TableValue__LookupsAssignment_4_1_3)*
+{ after(grammarAccess.getTableValueAccess().getLookupsAssignment_4_1_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_4_1__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableValue__Group_4_1__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_1__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getRightCurlyBracketKeyword_4_1_4()); }
+
+ '}'
+
+{ after(grammarAccess.getTableValueAccess().getRightCurlyBracketKeyword_4_1_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__TableFormatter__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableFormatter__Group__0__Impl
+ rule__TableFormatter__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableFormatter__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableFormatterAccess().getTableFormatterAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableFormatterAccess().getTableFormatterAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableFormatter__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableFormatter__Group__1__Impl
+ rule__TableFormatter__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableFormatter__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableFormatterAccess().getFormatterKeyword_1()); }
+
+ 'formatter'
+
+{ after(grammarAccess.getTableFormatterAccess().getFormatterKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableFormatter__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableFormatter__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableFormatter__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableFormatterAccess().getFormatAssignment_2()); }
+(rule__TableFormatter__FormatAssignment_2)
+{ after(grammarAccess.getTableFormatterAccess().getFormatAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__TableImage__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableImage__Group__0__Impl
+ rule__TableImage__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableImage__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableImageAccess().getTableImageAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableImageAccess().getTableImageAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableImage__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableImage__Group__1__Impl
+ rule__TableImage__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableImage__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableImageAccess().getPathKeyword_1()); }
+
+ 'path'
+
+{ after(grammarAccess.getTableImageAccess().getPathKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableImage__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableImage__Group__2__Impl
+ rule__TableImage__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableImage__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableImageAccess().getImagePathPatternAssignment_2()); }
+(rule__TableImage__ImagePathPatternAssignment_2)
+{ after(grammarAccess.getTableImageAccess().getImagePathPatternAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableImage__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableImage__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableImage__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableImageAccess().getUnorderedGroup_3()); }
+(rule__TableImage__UnorderedGroup_3)
+{ after(grammarAccess.getTableImageAccess().getUnorderedGroup_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TableImage__Group_3_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableImage__Group_3_2__0__Impl
+ rule__TableImage__Group_3_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableImage__Group_3_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableImageAccess().getResizeAssignment_3_2_0()); }
+(rule__TableImage__ResizeAssignment_3_2_0)
+{ after(grammarAccess.getTableImageAccess().getResizeAssignment_3_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableImage__Group_3_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableImage__Group_3_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableImage__Group_3_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableImageAccess().getResizeStringAssignment_3_2_1()); }
+(rule__TableImage__ResizeStringAssignment_3_2_1)
+{ after(grammarAccess.getTableImageAccess().getResizeStringAssignment_3_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableTooltipPattern__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTooltipPattern__Group__0__Impl
+ rule__TableTooltipPattern__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTooltipPattern__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTooltipPatternAccess().getTableTooltipPatternAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableTooltipPatternAccess().getTableTooltipPatternAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableTooltipPattern__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTooltipPattern__Group__1__Impl
+ rule__TableTooltipPattern__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTooltipPattern__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTooltipPatternAccess().getTooltipPatternKeyword_1()); }
+
+ 'tooltipPattern'
+
+{ after(grammarAccess.getTableTooltipPatternAccess().getTooltipPatternKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableTooltipPattern__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTooltipPattern__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTooltipPattern__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTooltipPatternAccess().getTooltipPatternAssignment_2()); }
+(rule__TableTooltipPattern__TooltipPatternAssignment_2)
+{ after(grammarAccess.getTableTooltipPatternAccess().getTooltipPatternAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__TableTask__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTask__Group__0__Impl
+ rule__TableTask__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTask__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTaskAccess().getTableTaskAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableTaskAccess().getTableTaskAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableTask__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableTask__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableTask__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableTaskAccess().getTaskIdKeyword_1()); }
+
+ 'taskId'
+
+{ after(grammarAccess.getTableTaskAccess().getTaskIdKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableAllColumns__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableAllColumns__Group__0__Impl
+ rule__TableAllColumns__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableAllColumns__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableAllColumnsAccess().getTableAllColumnsAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableAllColumnsAccess().getTableAllColumnsAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableAllColumns__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableAllColumns__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableAllColumns__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableAllColumnsAccess().getAllColumnsKeyword_1()); }
+
+ 'allColumns'
+
+{ after(grammarAccess.getTableAllColumnsAccess().getAllColumnsKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableOrdinal__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableOrdinal__Group__0__Impl
+ rule__TableOrdinal__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableOrdinal__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableOrdinalAccess().getOrdinalKeyword_0()); }
+
+ 'ordinal'
+
+{ after(grammarAccess.getTableOrdinalAccess().getOrdinalKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableOrdinal__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableOrdinal__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableOrdinal__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableOrdinalAccess().getValueRefAssignment_1()); }
+(rule__TableOrdinal__ValueRefAssignment_1)
+{ after(grammarAccess.getTableOrdinalAccess().getValueRefAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableColumn__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableColumn__Group__0__Impl
+ rule__TableColumn__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableColumn__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableColumnAccess().getColumnKeyword_0()); }
+
+ 'column'
+
+{ after(grammarAccess.getTableColumnAccess().getColumnKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableColumn__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableColumn__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableColumn__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableColumnAccess().getValueRefAssignment_1()); }
+(rule__TableColumn__ValueRefAssignment_1)
+{ after(grammarAccess.getTableColumnAccess().getValueRefAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableMeasure__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableMeasure__Group__0__Impl
+ rule__TableMeasure__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableMeasure__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableMeasureAccess().getMeasureKeyword_0()); }
+
+ 'measure'
+
+{ after(grammarAccess.getTableMeasureAccess().getMeasureKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableMeasure__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableMeasure__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableMeasure__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableMeasureAccess().getValueRefAssignment_1()); }
+(rule__TableMeasure__ValueRefAssignment_1)
+{ after(grammarAccess.getTableMeasureAccess().getValueRefAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableDerived__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableDerived__Group__0__Impl
+ rule__TableDerived__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableDerived__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableDerivedAccess().getDerivedKeyword_0()); }
+
+ 'derived'
+
+{ after(grammarAccess.getTableDerivedAccess().getDerivedKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableDerived__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableDerived__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableDerived__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableDerivedAccess().getValueRefAssignment_1()); }
+(rule__TableDerived__ValueRefAssignment_1)
+{ after(grammarAccess.getTableDerivedAccess().getValueRefAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableHierarchy__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableHierarchy__Group__0__Impl
+ rule__TableHierarchy__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableHierarchy__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableHierarchyAccess().getLevelKeyword_0()); }
+
+ 'level'
+
+{ after(grammarAccess.getTableHierarchyAccess().getLevelKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableHierarchy__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableHierarchy__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableHierarchy__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableHierarchyAccess().getValueRefAssignment_1()); }
+(rule__TableHierarchy__ValueRefAssignment_1)
+{ after(grammarAccess.getTableHierarchyAccess().getValueRefAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableProperty__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableProperty__Group__0__Impl
+ rule__TableProperty__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableProperty__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTablePropertyAccess().getTablePropertyAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTablePropertyAccess().getTablePropertyAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableProperty__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableProperty__Group__1__Impl
+ rule__TableProperty__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableProperty__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTablePropertyAccess().getPropertyKeyword_1()); }
+
+ 'property'
+
+{ after(grammarAccess.getTablePropertyAccess().getPropertyKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableProperty__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableProperty__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableProperty__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTablePropertyAccess().getValueRefAssignment_2()); }
+(rule__TableProperty__ValueRefAssignment_2)
+{ after(grammarAccess.getTablePropertyAccess().getValueRefAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__TableAggregation__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableAggregation__Group__0__Impl
+ rule__TableAggregation__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableAggregation__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableAggregationAccess().getAggregationKeyword_0()); }
+
+ 'aggregation'
+
+{ after(grammarAccess.getTableAggregationAccess().getAggregationKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableAggregation__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableAggregation__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableAggregation__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableAggregationAccess().getValueRefAssignment_1()); }
+(rule__TableAggregation__ValueRefAssignment_1)
+{ after(grammarAccess.getTableAggregationAccess().getValueRefAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableNumberInterval__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableNumberInterval__Group__0__Impl
+ rule__TableNumberInterval__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableNumberInterval__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableNumberIntervalAccess().getTableNumberIntervalAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableNumberIntervalAccess().getTableNumberIntervalAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableNumberInterval__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableNumberInterval__Group__1__Impl
+ rule__TableNumberInterval__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableNumberInterval__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableNumberIntervalAccess().getUpToKeyword_1()); }
+
+ 'up to'
+
+{ after(grammarAccess.getTableNumberIntervalAccess().getUpToKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableNumberInterval__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableNumberInterval__Group__2__Impl
+ rule__TableNumberInterval__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableNumberInterval__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableNumberIntervalAccess().getNumberIntervalValueAssignment_2()); }
+(rule__TableNumberInterval__NumberIntervalValueAssignment_2)
+{ after(grammarAccess.getTableNumberIntervalAccess().getNumberIntervalValueAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableNumberInterval__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableNumberInterval__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableNumberInterval__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableNumberIntervalAccess().getNumberRangeAssignment_3()); }
+(rule__TableNumberInterval__NumberRangeAssignment_3)
+{ after(grammarAccess.getTableNumberIntervalAccess().getNumberRangeAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TableDateDayInterval__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableDateDayInterval__Group__0__Impl
+ rule__TableDateDayInterval__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableDateDayInterval__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableDateDayIntervalAccess().getTableDateDayIntervalAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableDateDayIntervalAccess().getTableDateDayIntervalAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableDateDayInterval__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableDateDayInterval__Group__1__Impl
+ rule__TableDateDayInterval__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableDateDayInterval__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableDateDayIntervalAccess().getDaysInPastKeyword_1()); }
+
+ 'days in past'
+
+{ after(grammarAccess.getTableDateDayIntervalAccess().getDaysInPastKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableDateDayInterval__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableDateDayInterval__Group__2__Impl
+ rule__TableDateDayInterval__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableDateDayInterval__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableDateDayIntervalAccess().getDateIntervalValueAssignment_2()); }
+(rule__TableDateDayInterval__DateIntervalValueAssignment_2)
+{ after(grammarAccess.getTableDateDayIntervalAccess().getDateIntervalValueAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableDateDayInterval__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableDateDayInterval__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableDateDayInterval__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableDateDayIntervalAccess().getDateRangeAssignment_3()); }
+(rule__TableDateDayInterval__DateRangeAssignment_3)
+{ after(grammarAccess.getTableDateDayIntervalAccess().getDateRangeAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TableNumberLookup__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableNumberLookup__Group__0__Impl
+ rule__TableNumberLookup__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableNumberLookup__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableNumberLookupAccess().getTableNumberLookupAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableNumberLookupAccess().getTableNumberLookupAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableNumberLookup__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableNumberLookup__Group__1__Impl
+ rule__TableNumberLookup__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableNumberLookup__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableNumberLookupAccess().getNumberKeyword_1()); }
+
+ 'number'
+
+{ after(grammarAccess.getTableNumberLookupAccess().getNumberKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableNumberLookup__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableNumberLookup__Group__2__Impl
+ rule__TableNumberLookup__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableNumberLookup__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableNumberLookupAccess().getLookupValueAssignment_2()); }
+(rule__TableNumberLookup__LookupValueAssignment_2)
+{ after(grammarAccess.getTableNumberLookupAccess().getLookupValueAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableNumberLookup__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableNumberLookup__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableNumberLookup__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableNumberLookupAccess().getDiscreteAssignment_3()); }
+(rule__TableNumberLookup__DiscreteAssignment_3)
+{ after(grammarAccess.getTableNumberLookupAccess().getDiscreteAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TableStringLookup__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableStringLookup__Group__0__Impl
+ rule__TableStringLookup__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableStringLookup__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableStringLookupAccess().getTableStringLookupAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableStringLookupAccess().getTableStringLookupAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableStringLookup__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableStringLookup__Group__1__Impl
+ rule__TableStringLookup__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableStringLookup__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableStringLookupAccess().getStringKeyword_1()); }
+
+ 'string'
+
+{ after(grammarAccess.getTableStringLookupAccess().getStringKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableStringLookup__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableStringLookup__Group__2__Impl
+ rule__TableStringLookup__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableStringLookup__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableStringLookupAccess().getLookupValueAssignment_2()); }
+(rule__TableStringLookup__LookupValueAssignment_2)
+{ after(grammarAccess.getTableStringLookupAccess().getLookupValueAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableStringLookup__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableStringLookup__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableStringLookup__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableStringLookupAccess().getDiscreteAssignment_3()); }
+(rule__TableStringLookup__DiscreteAssignment_3)
+{ after(grammarAccess.getTableStringLookupAccess().getDiscreteAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TableDateDayLookup__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableDateDayLookup__Group__0__Impl
+ rule__TableDateDayLookup__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableDateDayLookup__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableDateDayLookupAccess().getTableDateDayLookupAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableDateDayLookupAccess().getTableDateDayLookupAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableDateDayLookup__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableDateDayLookup__Group__1__Impl
+ rule__TableDateDayLookup__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableDateDayLookup__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableDateDayLookupAccess().getDaysInPastKeyword_1()); }
+
+ 'days in past'
+
+{ after(grammarAccess.getTableDateDayLookupAccess().getDaysInPastKeyword_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableDateDayLookup__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableDateDayLookup__Group__2__Impl
+ rule__TableDateDayLookup__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableDateDayLookup__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableDateDayLookupAccess().getLookupValueAssignment_2()); }
+(rule__TableDateDayLookup__LookupValueAssignment_2)
+{ after(grammarAccess.getTableDateDayLookupAccess().getLookupValueAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableDateDayLookup__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableDateDayLookup__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableDateDayLookup__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableDateDayLookupAccess().getDiscreteAssignment_3()); }
+(rule__TableDateDayLookup__DiscreteAssignment_3)
+{ after(grammarAccess.getTableDateDayLookupAccess().getDiscreteAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TableDatamart__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableDatamart__Group__0__Impl
+ rule__TableDatamart__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableDatamart__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableDatamartAccess().getDatamartKeyword_0()); }
+
+ 'datamart'
+
+{ after(grammarAccess.getTableDatamartAccess().getDatamartKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableDatamart__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableDatamart__Group__1__Impl
+ rule__TableDatamart__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableDatamart__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableDatamartAccess().getDatamartRefAssignment_1()); }
+(rule__TableDatamart__DatamartRefAssignment_1)
+{ after(grammarAccess.getTableDatamartAccess().getDatamartRefAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableDatamart__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableDatamart__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableDatamart__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableDatamartAccess().getGroup_2()); }
+(rule__TableDatamart__Group_2__0)?
+{ after(grammarAccess.getTableDatamartAccess().getGroup_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__TableDatamart__Group_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableDatamart__Group_2__0__Impl
+ rule__TableDatamart__Group_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableDatamart__Group_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableDatamartAccess().getLeftCurlyBracketKeyword_2_0()); }
+
+ '{'
+
+{ after(grammarAccess.getTableDatamartAccess().getLeftCurlyBracketKeyword_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableDatamart__Group_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableDatamart__Group_2__1__Impl
+ rule__TableDatamart__Group_2__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableDatamart__Group_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableDatamartAccess().getElementsAssignment_2_1()); }
+(rule__TableDatamart__ElementsAssignment_2_1)*
+{ after(grammarAccess.getTableDatamartAccess().getElementsAssignment_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableDatamart__Group_2__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableDatamart__Group_2__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableDatamart__Group_2__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableDatamartAccess().getRightCurlyBracketKeyword_2_2()); }
+
+ '}'
+
+{ after(grammarAccess.getTableDatamartAccess().getRightCurlyBracketKeyword_2_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__TableEvent__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableEvent__Group__0__Impl
+ rule__TableEvent__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableEvent__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableEventAccess().getBrokerKeyword_0()); }
+
+ 'broker'
+
+{ after(grammarAccess.getTableEventAccess().getBrokerKeyword_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableEvent__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableEvent__Group__1__Impl
+ rule__TableEvent__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableEvent__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTableEventAccess().getSourceAssignment_1()); }
+(rule__TableEvent__SourceAssignment_1)
+{ after(grammarAccess.getTableEventAccess().getSourceAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TableEvent__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TableEvent__Group__2__Impl
+ rule__TableEvent__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TableEvent__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();

Back to the top