blob: c553ed8461d8ed973513ffd53698862f8b1ff09b [file] [log] [blame]
/**
*
* 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 InternalReportDSL;
options {
superClass=AbstractInternalContentAssistParser;
backtrack=true;
}
@lexer::header {
package org.eclipse.osbp.xtext.reportdsl.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.reportdsl.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.reportdsl.services.ReportDSLGrammarAccess;
}
@parser::members {
private ReportDSLGrammarAccess grammarAccess;
public void setGrammarAccess(ReportDSLGrammarAccess grammarAccess) {
this.grammarAccess = grammarAccess;
}
@Override
protected Grammar getGrammar() {
return grammarAccess.getGrammar();
}
@Override
protected String getValueForTokenName(String tokenName) {
return tokenName;
}
}
// Entry rule entryRuleReportModel
entryRuleReportModel
:
{ before(grammarAccess.getReportModelRule()); }
ruleReportModel
{ after(grammarAccess.getReportModelRule()); }
EOF
;
// Rule ReportModel
ruleReportModel
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getReportModelAccess().getPckgAssignment()); }
(rule__ReportModel__PckgAssignment)*
{ after(grammarAccess.getReportModelAccess().getPckgAssignment()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleReportPackage
entryRuleReportPackage
:
{ before(grammarAccess.getReportPackageRule()); }
ruleReportPackage
{ after(grammarAccess.getReportPackageRule()); }
EOF
;
// Rule ReportPackage
ruleReportPackage
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getReportPackageAccess().getGroup()); }
(rule__ReportPackage__Group__0)
{ after(grammarAccess.getReportPackageAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePageTemplates
entryRulePageTemplates
:
{ before(grammarAccess.getPageTemplatesRule()); }
rulePageTemplates
{ after(grammarAccess.getPageTemplatesRule()); }
EOF
;
// Rule PageTemplates
rulePageTemplates
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPageTemplatesAccess().getGroup()); }
(rule__PageTemplates__Group__0)
{ after(grammarAccess.getPageTemplatesAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleSomeFormats
entryRuleSomeFormats
:
{ before(grammarAccess.getSomeFormatsRule()); }
ruleSomeFormats
{ after(grammarAccess.getSomeFormatsRule()); }
EOF
;
// Rule SomeFormats
ruleSomeFormats
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getSomeFormatsAccess().getGroup()); }
(rule__SomeFormats__Group__0)
{ after(grammarAccess.getSomeFormatsAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleColors
entryRuleColors
:
{ before(grammarAccess.getColorsRule()); }
ruleColors
{ after(grammarAccess.getColorsRule()); }
EOF
;
// Rule Colors
ruleColors
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getColorsAccess().getGroup()); }
(rule__Colors__Group__0)
{ after(grammarAccess.getColorsAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleFonts
entryRuleFonts
:
{ before(grammarAccess.getFontsRule()); }
ruleFonts
{ after(grammarAccess.getFontsRule()); }
EOF
;
// Rule Fonts
ruleFonts
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getFontsAccess().getGroup()); }
(rule__Fonts__Group__0)
{ after(grammarAccess.getFontsAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleMedias
entryRuleMedias
:
{ before(grammarAccess.getMediasRule()); }
ruleMedias
{ after(grammarAccess.getMediasRule()); }
EOF
;
// Rule Medias
ruleMedias
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getMediasAccess().getGroup()); }
(rule__Medias__Group__0)
{ after(grammarAccess.getMediasAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleMedia
entryRuleMedia
:
{ before(grammarAccess.getMediaRule()); }
ruleMedia
{ after(grammarAccess.getMediaRule()); }
EOF
;
// Rule Media
ruleMedia
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getMediaAccess().getGroup()); }
(rule__Media__Group__0)
{ after(grammarAccess.getMediaAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleStyles
entryRuleStyles
:
{ before(grammarAccess.getStylesRule()); }
ruleStyles
{ after(grammarAccess.getStylesRule()); }
EOF
;
// Rule Styles
ruleStyles
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getStylesAccess().getGroup()); }
(rule__Styles__Group__0)
{ after(grammarAccess.getStylesAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePageTemplate
entryRulePageTemplate
:
{ before(grammarAccess.getPageTemplateRule()); }
rulePageTemplate
{ after(grammarAccess.getPageTemplateRule()); }
EOF
;
// Rule PageTemplate
rulePageTemplate
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPageTemplateAccess().getGroup()); }
(rule__PageTemplate__Group__0)
{ after(grammarAccess.getPageTemplateAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleUnsignedNumber
entryRuleUnsignedNumber
:
{ before(grammarAccess.getUnsignedNumberRule()); }
ruleUnsignedNumber
{ after(grammarAccess.getUnsignedNumberRule()); }
EOF
;
// Rule UnsignedNumber
ruleUnsignedNumber
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getUnsignedNumberAccess().getNumberParserRuleCall()); }
ruleNumber
{ after(grammarAccess.getUnsignedNumberAccess().getNumberParserRuleCall()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleColor
entryRuleColor
:
{ before(grammarAccess.getColorRule()); }
ruleColor
{ after(grammarAccess.getColorRule()); }
EOF
;
// Rule Color
ruleColor
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getColorAccess().getGroup()); }
(rule__Color__Group__0)
{ after(grammarAccess.getColorAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleFont
entryRuleFont
:
{ before(grammarAccess.getFontRule()); }
ruleFont
{ after(grammarAccess.getFontRule()); }
EOF
;
// Rule Font
ruleFont
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getFontAccess().getUnorderedGroup()); }
(rule__Font__UnorderedGroup)
{ after(grammarAccess.getFontAccess().getUnorderedGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleFontFamily
entryRuleFontFamily
:
{ before(grammarAccess.getFontFamilyRule()); }
ruleFontFamily
{ after(grammarAccess.getFontFamilyRule()); }
EOF
;
// Rule FontFamily
ruleFontFamily
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getFontFamilyAccess().getAlternatives()); }
(rule__FontFamily__Alternatives)
{ after(grammarAccess.getFontFamilyAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleBuildInFontFamily
entryRuleBuildInFontFamily
:
{ before(grammarAccess.getBuildInFontFamilyRule()); }
ruleBuildInFontFamily
{ after(grammarAccess.getBuildInFontFamilyRule()); }
EOF
;
// Rule BuildInFontFamily
ruleBuildInFontFamily
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getBuildInFontFamilyAccess().getCustomAssignment()); }
(rule__BuildInFontFamily__CustomAssignment)
{ after(grammarAccess.getBuildInFontFamilyAccess().getCustomAssignment()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleCustomFontFamily
entryRuleCustomFontFamily
:
{ before(grammarAccess.getCustomFontFamilyRule()); }
ruleCustomFontFamily
{ after(grammarAccess.getCustomFontFamilyRule()); }
EOF
;
// Rule CustomFontFamily
ruleCustomFontFamily
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getCustomFontFamilyAccess().getCustomAssignment()); }
(rule__CustomFontFamily__CustomAssignment)
{ after(grammarAccess.getCustomFontFamilyAccess().getCustomAssignment()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleBorderStyle
entryRuleBorderStyle
:
{ before(grammarAccess.getBorderStyleRule()); }
ruleBorderStyle
{ after(grammarAccess.getBorderStyleRule()); }
EOF
;
// Rule BorderStyle
ruleBorderStyle
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getBorderStyleAccess().getGroup()); }
(rule__BorderStyle__Group__0)
{ after(grammarAccess.getBorderStyleAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleStyle
entryRuleStyle
:
{ before(grammarAccess.getStyleRule()); }
ruleStyle
{ after(grammarAccess.getStyleRule()); }
EOF
;
// Rule Style
ruleStyle
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getStyleAccess().getGroup()); }
(rule__Style__Group__0)
{ after(grammarAccess.getStyleAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleMediaStyle
entryRuleMediaStyle
:
{ before(grammarAccess.getMediaStyleRule()); }
ruleMediaStyle
{ after(grammarAccess.getMediaStyleRule()); }
EOF
;
// Rule MediaStyle
ruleMediaStyle
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getMediaStyleAccess().getGroup()); }
(rule__MediaStyle__Group__0)
{ after(grammarAccess.getMediaStyleAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleSomeFormat
entryRuleSomeFormat
:
{ before(grammarAccess.getSomeFormatRule()); }
ruleSomeFormat
{ after(grammarAccess.getSomeFormatRule()); }
EOF
;
// Rule SomeFormat
ruleSomeFormat
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getSomeFormatAccess().getAlternatives()); }
(rule__SomeFormat__Alternatives)
{ after(grammarAccess.getSomeFormatAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleUomoFormat
entryRuleUomoFormat
:
{ before(grammarAccess.getUomoFormatRule()); }
ruleUomoFormat
{ after(grammarAccess.getUomoFormatRule()); }
EOF
;
// Rule UomoFormat
ruleUomoFormat
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getUomoFormatAccess().getGroup()); }
(rule__UomoFormat__Group__0)
{ after(grammarAccess.getUomoFormatAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleNumberFormat
entryRuleNumberFormat
:
{ before(grammarAccess.getNumberFormatRule()); }
ruleNumberFormat
{ after(grammarAccess.getNumberFormatRule()); }
EOF
;
// Rule NumberFormat
ruleNumberFormat
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getNumberFormatAccess().getGroup()); }
(rule__NumberFormat__Group__0)
{ after(grammarAccess.getNumberFormatAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleCurrencyFormat
entryRuleCurrencyFormat
:
{ before(grammarAccess.getCurrencyFormatRule()); }
ruleCurrencyFormat
{ after(grammarAccess.getCurrencyFormatRule()); }
EOF
;
// Rule CurrencyFormat
ruleCurrencyFormat
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getCurrencyFormatAccess().getGroup()); }
(rule__CurrencyFormat__Group__0)
{ after(grammarAccess.getCurrencyFormatAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleDateFormat
entryRuleDateFormat
:
{ before(grammarAccess.getDateFormatRule()); }
ruleDateFormat
{ after(grammarAccess.getDateFormatRule()); }
EOF
;
// Rule DateFormat
ruleDateFormat
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getDateFormatAccess().getGroup()); }
(rule__DateFormat__Group__0)
{ after(grammarAccess.getDateFormatAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleDateTimeFormat
entryRuleDateTimeFormat
:
{ before(grammarAccess.getDateTimeFormatRule()); }
ruleDateTimeFormat
{ after(grammarAccess.getDateTimeFormatRule()); }
EOF
;
// Rule DateTimeFormat
ruleDateTimeFormat
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getDateTimeFormatAccess().getGroup()); }
(rule__DateTimeFormat__Group__0)
{ after(grammarAccess.getDateTimeFormatAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTimeFormat
entryRuleTimeFormat
:
{ before(grammarAccess.getTimeFormatRule()); }
ruleTimeFormat
{ after(grammarAccess.getTimeFormatRule()); }
EOF
;
// Rule TimeFormat
ruleTimeFormat
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTimeFormatAccess().getGroup()); }
(rule__TimeFormat__Group__0)
{ after(grammarAccess.getTimeFormatAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleReport
entryRuleReport
:
{ before(grammarAccess.getReportRule()); }
ruleReport
{ after(grammarAccess.getReportRule()); }
EOF
;
// Rule Report
ruleReport
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getReportAccess().getGroup()); }
(rule__Report__Group__0)
{ after(grammarAccess.getReportAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleReportDesign
entryRuleReportDesign
:
{ before(grammarAccess.getReportDesignRule()); }
ruleReportDesign
{ after(grammarAccess.getReportDesignRule()); }
EOF
;
// Rule ReportDesign
ruleReportDesign
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getReportDesignAccess().getAlternatives()); }
(rule__ReportDesign__Alternatives)
{ after(grammarAccess.getReportDesignAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleReportDesignFile
entryRuleReportDesignFile
:
{ before(grammarAccess.getReportDesignFileRule()); }
ruleReportDesignFile
{ after(grammarAccess.getReportDesignFileRule()); }
EOF
;
// Rule ReportDesignFile
ruleReportDesignFile
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getReportDesignFileAccess().getGroup()); }
(rule__ReportDesignFile__Group__0)
{ after(grammarAccess.getReportDesignFileAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleReportDesignTemplate
entryRuleReportDesignTemplate
:
{ before(grammarAccess.getReportDesignTemplateRule()); }
ruleReportDesignTemplate
{ after(grammarAccess.getReportDesignTemplateRule()); }
EOF
;
// Rule ReportDesignTemplate
ruleReportDesignTemplate
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getReportDesignTemplateAccess().getGroup()); }
(rule__ReportDesignTemplate__Group__0)
{ after(grammarAccess.getReportDesignTemplateAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePageHeader
entryRulePageHeader
:
{ before(grammarAccess.getPageHeaderRule()); }
rulePageHeader
{ after(grammarAccess.getPageHeaderRule()); }
EOF
;
// Rule PageHeader
rulePageHeader
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPageHeaderAccess().getGroup()); }
(rule__PageHeader__Group__0)
{ after(grammarAccess.getPageHeaderAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePageDetail
entryRulePageDetail
:
{ before(grammarAccess.getPageDetailRule()); }
rulePageDetail
{ after(grammarAccess.getPageDetailRule()); }
EOF
;
// Rule PageDetail
rulePageDetail
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPageDetailAccess().getGroup()); }
(rule__PageDetail__Group__0)
{ after(grammarAccess.getPageDetailAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePageFooter
entryRulePageFooter
:
{ before(grammarAccess.getPageFooterRule()); }
rulePageFooter
{ after(grammarAccess.getPageFooterRule()); }
EOF
;
// Rule PageFooter
rulePageFooter
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPageFooterAccess().getGroup()); }
(rule__PageFooter__Group__0)
{ after(grammarAccess.getPageFooterAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleElement
entryRuleElement
:
{ before(grammarAccess.getElementRule()); }
ruleElement
{ after(grammarAccess.getElementRule()); }
EOF
;
// Rule Element
ruleElement
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getElementAccess().getAlternatives()); }
(rule__Element__Alternatives)
{ after(grammarAccess.getElementAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleGrid
entryRuleGrid
:
{ before(grammarAccess.getGridRule()); }
ruleGrid
{ after(grammarAccess.getGridRule()); }
EOF
;
// Rule Grid
ruleGrid
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getGridAccess().getGroup()); }
(rule__Grid__Group__0)
{ after(grammarAccess.getGridAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleGridRow
entryRuleGridRow
:
{ before(grammarAccess.getGridRowRule()); }
ruleGridRow
{ after(grammarAccess.getGridRowRule()); }
EOF
;
// Rule GridRow
ruleGridRow
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getGridRowAccess().getGroup()); }
(rule__GridRow__Group__0)
{ after(grammarAccess.getGridRowAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleGridCell
entryRuleGridCell
:
{ before(grammarAccess.getGridCellRule()); }
ruleGridCell
{ after(grammarAccess.getGridCellRule()); }
EOF
;
// Rule GridCell
ruleGridCell
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getGridCellAccess().getGroup()); }
(rule__GridCell__Group__0)
{ after(grammarAccess.getGridCellAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleDatamartTable
entryRuleDatamartTable
:
{ before(grammarAccess.getDatamartTableRule()); }
ruleDatamartTable
{ after(grammarAccess.getDatamartTableRule()); }
EOF
;
// Rule DatamartTable
ruleDatamartTable
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getDatamartTableAccess().getGroup()); }
(rule__DatamartTable__Group__0)
{ after(grammarAccess.getDatamartTableAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleDatamartTableGroup
entryRuleDatamartTableGroup
:
{ before(grammarAccess.getDatamartTableGroupRule()); }
ruleDatamartTableGroup
{ after(grammarAccess.getDatamartTableGroupRule()); }
EOF
;
// Rule DatamartTableGroup
ruleDatamartTableGroup
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getDatamartTableGroupAccess().getGroup()); }
(rule__DatamartTableGroup__Group__0)
{ after(grammarAccess.getDatamartTableGroupAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleDatamartTableGroupHeader
entryRuleDatamartTableGroupHeader
:
{ before(grammarAccess.getDatamartTableGroupHeaderRule()); }
ruleDatamartTableGroupHeader
{ after(grammarAccess.getDatamartTableGroupHeaderRule()); }
EOF
;
// Rule DatamartTableGroupHeader
ruleDatamartTableGroupHeader
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getDatamartTableGroupHeaderAccess().getGroup()); }
(rule__DatamartTableGroupHeader__Group__0)
{ after(grammarAccess.getDatamartTableGroupHeaderAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleDatamartTableGroupFooter
entryRuleDatamartTableGroupFooter
:
{ before(grammarAccess.getDatamartTableGroupFooterRule()); }
ruleDatamartTableGroupFooter
{ after(grammarAccess.getDatamartTableGroupFooterRule()); }
EOF
;
// Rule DatamartTableGroupFooter
ruleDatamartTableGroupFooter
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getDatamartTableGroupFooterAccess().getGroup()); }
(rule__DatamartTableGroupFooter__Group__0)
{ after(grammarAccess.getDatamartTableGroupFooterAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleDatamartTableDetail
entryRuleDatamartTableDetail
:
{ before(grammarAccess.getDatamartTableDetailRule()); }
ruleDatamartTableDetail
{ after(grammarAccess.getDatamartTableDetailRule()); }
EOF
;
// Rule DatamartTableDetail
ruleDatamartTableDetail
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getDatamartTableDetailAccess().getGroup()); }
(rule__DatamartTableDetail__Group__0)
{ after(grammarAccess.getDatamartTableDetailAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleDatamartTableProperty
entryRuleDatamartTableProperty
:
{ before(grammarAccess.getDatamartTablePropertyRule()); }
ruleDatamartTableProperty
{ after(grammarAccess.getDatamartTablePropertyRule()); }
EOF
;
// Rule DatamartTableProperty
ruleDatamartTableProperty
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getDatamartTablePropertyAccess().getGroup()); }
(rule__DatamartTableProperty__Group__0)
{ after(grammarAccess.getDatamartTablePropertyAccess().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 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 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 entryRuleTableBaseAggregation
entryRuleTableBaseAggregation
:
{ before(grammarAccess.getTableBaseAggregationRule()); }
ruleTableBaseAggregation
{ after(grammarAccess.getTableBaseAggregationRule()); }
EOF
;
// Rule TableBaseAggregation
ruleTableBaseAggregation
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTableBaseAggregationAccess().getAlternatives()); }
(rule__TableBaseAggregation__Alternatives)
{ after(grammarAccess.getTableBaseAggregationAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTablePureAggregation
entryRuleTablePureAggregation
:
{ before(grammarAccess.getTablePureAggregationRule()); }
ruleTablePureAggregation
{ after(grammarAccess.getTablePureAggregationRule()); }
EOF
;
// Rule TablePureAggregation
ruleTablePureAggregation
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTablePureAggregationAccess().getAggregationAssignment()); }
(rule__TablePureAggregation__AggregationAssignment)
{ after(grammarAccess.getTablePureAggregationAccess().getAggregationAssignment()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTableUnaryAggregation
entryRuleTableUnaryAggregation
:
{ before(grammarAccess.getTableUnaryAggregationRule()); }
ruleTableUnaryAggregation
{ after(grammarAccess.getTableUnaryAggregationRule()); }
EOF
;
// Rule TableUnaryAggregation
ruleTableUnaryAggregation
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTableUnaryAggregationAccess().getGroup()); }
(rule__TableUnaryAggregation__Group__0)
{ after(grammarAccess.getTableUnaryAggregationAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTableMultipleAggregation
entryRuleTableMultipleAggregation
:
{ before(grammarAccess.getTableMultipleAggregationRule()); }
ruleTableMultipleAggregation
{ after(grammarAccess.getTableMultipleAggregationRule()); }
EOF
;
// Rule TableMultipleAggregation
ruleTableMultipleAggregation
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTableMultipleAggregationAccess().getGroup()); }
(rule__TableMultipleAggregation__Group__0)
{ after(grammarAccess.getTableMultipleAggregationAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTableBinaryAggregation
entryRuleTableBinaryAggregation
:
{ before(grammarAccess.getTableBinaryAggregationRule()); }
ruleTableBinaryAggregation
{ after(grammarAccess.getTableBinaryAggregationRule()); }
EOF
;
// Rule TableBinaryAggregation
ruleTableBinaryAggregation
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTableBinaryAggregationAccess().getGroup()); }
(rule__TableBinaryAggregation__Group__0)
{ after(grammarAccess.getTableBinaryAggregationAccess().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 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 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 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 entryRuleTitle
entryRuleTitle
:
{ before(grammarAccess.getTitleRule()); }
ruleTitle
{ after(grammarAccess.getTitleRule()); }
EOF
;
// Rule Title
ruleTitle
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTitleAccess().getGroup()); }
(rule__Title__Group__0)
{ after(grammarAccess.getTitleAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleSubTitle
entryRuleSubTitle
:
{ before(grammarAccess.getSubTitleRule()); }
ruleSubTitle
{ after(grammarAccess.getSubTitleRule()); }
EOF
;
// Rule SubTitle
ruleSubTitle
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getSubTitleAccess().getGroup()); }
(rule__SubTitle__Group__0)
{ after(grammarAccess.getSubTitleAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleSubSubTitle
entryRuleSubSubTitle
:
{ before(grammarAccess.getSubSubTitleRule()); }
ruleSubSubTitle
{ after(grammarAccess.getSubSubTitleRule()); }
EOF
;
// Rule SubSubTitle
ruleSubSubTitle
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getSubSubTitleAccess().getGroup()); }
(rule__SubSubTitle__Group__0)
{ after(grammarAccess.getSubSubTitleAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleLabel
entryRuleLabel
:
{ before(grammarAccess.getLabelRule()); }
ruleLabel
{ after(grammarAccess.getLabelRule()); }
EOF
;
// Rule Label
ruleLabel
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getLabelAccess().getGroup()); }
(rule__Label__Group__0)
{ after(grammarAccess.getLabelAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleText
entryRuleText
:
{ before(grammarAccess.getTextRule()); }
ruleText
{ after(grammarAccess.getTextRule()); }
EOF
;
// Rule Text
ruleText
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTextAccess().getGroup()); }
(rule__Text__Group__0)
{ after(grammarAccess.getTextAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleAutoText
entryRuleAutoText
:
{ before(grammarAccess.getAutoTextRule()); }
ruleAutoText
{ after(grammarAccess.getAutoTextRule()); }
EOF
;
// Rule AutoText
ruleAutoText
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getAutoTextAccess().getGroup()); }
(rule__AutoText__Group__0)
{ after(grammarAccess.getAutoTextAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleImage
entryRuleImage
:
{ before(grammarAccess.getImageRule()); }
ruleImage
{ after(grammarAccess.getImageRule()); }
EOF
;
// Rule Image
ruleImage
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getImageAccess().getGroup()); }
(rule__Image__Group__0)
{ after(grammarAccess.getImageAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleReportImport
entryRuleReportImport
:
{ before(grammarAccess.getReportImportRule()); }
ruleReportImport
{ after(grammarAccess.getReportImportRule()); }
EOF
;
// Rule ReportImport
ruleReportImport
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getReportImportAccess().getGroup()); }
(rule__ReportImport__Group__0)
{ after(grammarAccess.getReportImportAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleReportQualifiedNameWithWildCard
entryRuleReportQualifiedNameWithWildCard
:
{ before(grammarAccess.getReportQualifiedNameWithWildCardRule()); }
ruleReportQualifiedNameWithWildCard
{ after(grammarAccess.getReportQualifiedNameWithWildCardRule()); }
EOF
;
// Rule ReportQualifiedNameWithWildCard
ruleReportQualifiedNameWithWildCard
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getReportQualifiedNameWithWildCardAccess().getGroup()); }
(rule__ReportQualifiedNameWithWildCard__Group__0)
{ after(grammarAccess.getReportQualifiedNameWithWildCardAccess().getGroup()); }
)
;
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 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();
}
: