blob: 15225d5fe69b6e561dfcfd808ef86ce371fc8803 [file] [log] [blame]
/*******************************************************************************
* Copyright (c) 2011, 2022 Willink Transformations and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v2.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v20.html
*
* Contributors:
* E.D.Willink - initial API and implementation
*******************************************************************************/
grammar InternalEssentialOCL;
options {
superClass=AbstractInternalContentAssistParser;
backtrack=true;
}
@lexer::header {
package org.eclipse.ocl.xtext.essentialocl.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.ocl.xtext.essentialocl.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.ocl.xtext.essentialocl.services.EssentialOCLGrammarAccess;
}
@parser::members {
private EssentialOCLGrammarAccess grammarAccess;
public void setGrammarAccess(EssentialOCLGrammarAccess grammarAccess) {
this.grammarAccess = grammarAccess;
}
@Override
protected Grammar getGrammar() {
return grammarAccess.getGrammar();
}
@Override
protected String getValueForTokenName(String tokenName) {
return tokenName;
}
}
// Entry rule entryRuleModel
entryRuleModel
:
{ before(grammarAccess.getModelRule()); }
ruleModel
{ after(grammarAccess.getModelRule()); }
EOF
;
// Rule Model
ruleModel
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getModelAccess().getOwnedExpressionAssignment()); }
(rule__Model__OwnedExpressionAssignment)
{ after(grammarAccess.getModelAccess().getOwnedExpressionAssignment()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleEssentialOCLUnaryOperatorName
entryRuleEssentialOCLUnaryOperatorName
:
{ before(grammarAccess.getEssentialOCLUnaryOperatorNameRule()); }
ruleEssentialOCLUnaryOperatorName
{ after(grammarAccess.getEssentialOCLUnaryOperatorNameRule()); }
EOF
;
// Rule EssentialOCLUnaryOperatorName
ruleEssentialOCLUnaryOperatorName
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getAlternatives()); }
(rule__EssentialOCLUnaryOperatorName__Alternatives)
{ after(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleEssentialOCLInfixOperatorName
entryRuleEssentialOCLInfixOperatorName
:
{ before(grammarAccess.getEssentialOCLInfixOperatorNameRule()); }
ruleEssentialOCLInfixOperatorName
{ after(grammarAccess.getEssentialOCLInfixOperatorNameRule()); }
EOF
;
// Rule EssentialOCLInfixOperatorName
ruleEssentialOCLInfixOperatorName
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAlternatives()); }
(rule__EssentialOCLInfixOperatorName__Alternatives)
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleEssentialOCLNavigationOperatorName
entryRuleEssentialOCLNavigationOperatorName
:
{ before(grammarAccess.getEssentialOCLNavigationOperatorNameRule()); }
ruleEssentialOCLNavigationOperatorName
{ after(grammarAccess.getEssentialOCLNavigationOperatorNameRule()); }
EOF
;
// Rule EssentialOCLNavigationOperatorName
ruleEssentialOCLNavigationOperatorName
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getAlternatives()); }
(rule__EssentialOCLNavigationOperatorName__Alternatives)
{ after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleBinaryOperatorName
entryRuleBinaryOperatorName
:
{ before(grammarAccess.getBinaryOperatorNameRule()); }
ruleBinaryOperatorName
{ after(grammarAccess.getBinaryOperatorNameRule()); }
EOF
;
// Rule BinaryOperatorName
ruleBinaryOperatorName
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getBinaryOperatorNameAccess().getAlternatives()); }
(rule__BinaryOperatorName__Alternatives)
{ after(grammarAccess.getBinaryOperatorNameAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleInfixOperatorName
entryRuleInfixOperatorName
:
{ before(grammarAccess.getInfixOperatorNameRule()); }
ruleInfixOperatorName
{ after(grammarAccess.getInfixOperatorNameRule()); }
EOF
;
// Rule InfixOperatorName
ruleInfixOperatorName
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getInfixOperatorNameAccess().getEssentialOCLInfixOperatorNameParserRuleCall()); }
ruleEssentialOCLInfixOperatorName
{ after(grammarAccess.getInfixOperatorNameAccess().getEssentialOCLInfixOperatorNameParserRuleCall()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleNavigationOperatorName
entryRuleNavigationOperatorName
:
{ before(grammarAccess.getNavigationOperatorNameRule()); }
ruleNavigationOperatorName
{ after(grammarAccess.getNavigationOperatorNameRule()); }
EOF
;
// Rule NavigationOperatorName
ruleNavigationOperatorName
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getNavigationOperatorNameAccess().getEssentialOCLNavigationOperatorNameParserRuleCall()); }
ruleEssentialOCLNavigationOperatorName
{ after(grammarAccess.getNavigationOperatorNameAccess().getEssentialOCLNavigationOperatorNameParserRuleCall()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleUnaryOperatorName
entryRuleUnaryOperatorName
:
{ before(grammarAccess.getUnaryOperatorNameRule()); }
ruleUnaryOperatorName
{ after(grammarAccess.getUnaryOperatorNameRule()); }
EOF
;
// Rule UnaryOperatorName
ruleUnaryOperatorName
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getUnaryOperatorNameAccess().getEssentialOCLUnaryOperatorNameParserRuleCall()); }
ruleEssentialOCLUnaryOperatorName
{ after(grammarAccess.getUnaryOperatorNameAccess().getEssentialOCLUnaryOperatorNameParserRuleCall()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleEssentialOCLUnrestrictedName
entryRuleEssentialOCLUnrestrictedName
:
{ before(grammarAccess.getEssentialOCLUnrestrictedNameRule()); }
ruleEssentialOCLUnrestrictedName
{ after(grammarAccess.getEssentialOCLUnrestrictedNameRule()); }
EOF
;
// Rule EssentialOCLUnrestrictedName
ruleEssentialOCLUnrestrictedName
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getEssentialOCLUnrestrictedNameAccess().getIdentifierParserRuleCall()); }
ruleIdentifier
{ after(grammarAccess.getEssentialOCLUnrestrictedNameAccess().getIdentifierParserRuleCall()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleUnrestrictedName
entryRuleUnrestrictedName
:
{ before(grammarAccess.getUnrestrictedNameRule()); }
ruleUnrestrictedName
{ after(grammarAccess.getUnrestrictedNameRule()); }
EOF
;
// Rule UnrestrictedName
ruleUnrestrictedName
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getUnrestrictedNameAccess().getEssentialOCLUnrestrictedNameParserRuleCall()); }
ruleEssentialOCLUnrestrictedName
{ after(grammarAccess.getUnrestrictedNameAccess().getEssentialOCLUnrestrictedNameParserRuleCall()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleEssentialOCLUnreservedName
entryRuleEssentialOCLUnreservedName
:
{ before(grammarAccess.getEssentialOCLUnreservedNameRule()); }
ruleEssentialOCLUnreservedName
{ after(grammarAccess.getEssentialOCLUnreservedNameRule()); }
EOF
;
// Rule EssentialOCLUnreservedName
ruleEssentialOCLUnreservedName
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getEssentialOCLUnreservedNameAccess().getAlternatives()); }
(rule__EssentialOCLUnreservedName__Alternatives)
{ after(grammarAccess.getEssentialOCLUnreservedNameAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleUnreservedName
entryRuleUnreservedName
:
{ before(grammarAccess.getUnreservedNameRule()); }
ruleUnreservedName
{ after(grammarAccess.getUnreservedNameRule()); }
EOF
;
// Rule UnreservedName
ruleUnreservedName
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getUnreservedNameAccess().getEssentialOCLUnreservedNameParserRuleCall()); }
ruleEssentialOCLUnreservedName
{ after(grammarAccess.getUnreservedNameAccess().getEssentialOCLUnreservedNameParserRuleCall()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleURIFirstPathElementCS
entryRuleURIFirstPathElementCS
:
{ before(grammarAccess.getURIFirstPathElementCSRule()); }
ruleURIFirstPathElementCS
{ after(grammarAccess.getURIFirstPathElementCSRule()); }
EOF
;
// Rule URIFirstPathElementCS
ruleURIFirstPathElementCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getURIFirstPathElementCSAccess().getAlternatives()); }
(rule__URIFirstPathElementCS__Alternatives)
{ after(grammarAccess.getURIFirstPathElementCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePrimitiveTypeIdentifier
entryRulePrimitiveTypeIdentifier
:
{ before(grammarAccess.getPrimitiveTypeIdentifierRule()); }
rulePrimitiveTypeIdentifier
{ after(grammarAccess.getPrimitiveTypeIdentifierRule()); }
EOF
;
// Rule PrimitiveTypeIdentifier
rulePrimitiveTypeIdentifier
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPrimitiveTypeIdentifierAccess().getAlternatives()); }
(rule__PrimitiveTypeIdentifier__Alternatives)
{ after(grammarAccess.getPrimitiveTypeIdentifierAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePrimitiveTypeCS
entryRulePrimitiveTypeCS
:
{ before(grammarAccess.getPrimitiveTypeCSRule()); }
rulePrimitiveTypeCS
{ after(grammarAccess.getPrimitiveTypeCSRule()); }
EOF
;
// Rule PrimitiveTypeCS
rulePrimitiveTypeCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPrimitiveTypeCSAccess().getNameAssignment()); }
(rule__PrimitiveTypeCS__NameAssignment)
{ after(grammarAccess.getPrimitiveTypeCSAccess().getNameAssignment()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleCollectionTypeIdentifier
entryRuleCollectionTypeIdentifier
:
{ before(grammarAccess.getCollectionTypeIdentifierRule()); }
ruleCollectionTypeIdentifier
{ after(grammarAccess.getCollectionTypeIdentifierRule()); }
EOF
;
// Rule CollectionTypeIdentifier
ruleCollectionTypeIdentifier
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getCollectionTypeIdentifierAccess().getAlternatives()); }
(rule__CollectionTypeIdentifier__Alternatives)
{ after(grammarAccess.getCollectionTypeIdentifierAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleCollectionTypeCS
entryRuleCollectionTypeCS
:
{ before(grammarAccess.getCollectionTypeCSRule()); }
ruleCollectionTypeCS
{ after(grammarAccess.getCollectionTypeCSRule()); }
EOF
;
// Rule CollectionTypeCS
ruleCollectionTypeCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getCollectionTypeCSAccess().getGroup()); }
(rule__CollectionTypeCS__Group__0)
{ after(grammarAccess.getCollectionTypeCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleMapTypeCS
entryRuleMapTypeCS
:
{ before(grammarAccess.getMapTypeCSRule()); }
ruleMapTypeCS
{ after(grammarAccess.getMapTypeCSRule()); }
EOF
;
// Rule MapTypeCS
ruleMapTypeCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getMapTypeCSAccess().getGroup()); }
(rule__MapTypeCS__Group__0)
{ after(grammarAccess.getMapTypeCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTupleTypeCS
entryRuleTupleTypeCS
:
{ before(grammarAccess.getTupleTypeCSRule()); }
ruleTupleTypeCS
{ after(grammarAccess.getTupleTypeCSRule()); }
EOF
;
// Rule TupleTypeCS
ruleTupleTypeCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTupleTypeCSAccess().getGroup()); }
(rule__TupleTypeCS__Group__0)
{ after(grammarAccess.getTupleTypeCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTuplePartCS
entryRuleTuplePartCS
:
{ before(grammarAccess.getTuplePartCSRule()); }
ruleTuplePartCS
{ after(grammarAccess.getTuplePartCSRule()); }
EOF
;
// Rule TuplePartCS
ruleTuplePartCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTuplePartCSAccess().getGroup()); }
(rule__TuplePartCS__Group__0)
{ after(grammarAccess.getTuplePartCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleCollectionLiteralExpCS
entryRuleCollectionLiteralExpCS
:
{ before(grammarAccess.getCollectionLiteralExpCSRule()); }
ruleCollectionLiteralExpCS
{ after(grammarAccess.getCollectionLiteralExpCSRule()); }
EOF
;
// Rule CollectionLiteralExpCS
ruleCollectionLiteralExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getCollectionLiteralExpCSAccess().getGroup()); }
(rule__CollectionLiteralExpCS__Group__0)
{ after(grammarAccess.getCollectionLiteralExpCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleCollectionLiteralPartCS
entryRuleCollectionLiteralPartCS
:
{ before(grammarAccess.getCollectionLiteralPartCSRule()); }
ruleCollectionLiteralPartCS
{ after(grammarAccess.getCollectionLiteralPartCSRule()); }
EOF
;
// Rule CollectionLiteralPartCS
ruleCollectionLiteralPartCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getCollectionLiteralPartCSAccess().getAlternatives()); }
(rule__CollectionLiteralPartCS__Alternatives)
{ after(grammarAccess.getCollectionLiteralPartCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleCollectionPatternCS
entryRuleCollectionPatternCS
:
{ before(grammarAccess.getCollectionPatternCSRule()); }
ruleCollectionPatternCS
{ after(grammarAccess.getCollectionPatternCSRule()); }
EOF
;
// Rule CollectionPatternCS
ruleCollectionPatternCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getCollectionPatternCSAccess().getGroup()); }
(rule__CollectionPatternCS__Group__0)
{ after(grammarAccess.getCollectionPatternCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleShadowPartCS
entryRuleShadowPartCS
:
{ before(grammarAccess.getShadowPartCSRule()); }
ruleShadowPartCS
{ after(grammarAccess.getShadowPartCSRule()); }
EOF
;
// Rule ShadowPartCS
ruleShadowPartCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getShadowPartCSAccess().getAlternatives()); }
(rule__ShadowPartCS__Alternatives)
{ after(grammarAccess.getShadowPartCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePatternExpCS
entryRulePatternExpCS
:
{ before(grammarAccess.getPatternExpCSRule()); }
rulePatternExpCS
{ after(grammarAccess.getPatternExpCSRule()); }
EOF
;
// Rule PatternExpCS
rulePatternExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPatternExpCSAccess().getGroup()); }
(rule__PatternExpCS__Group__0)
{ after(grammarAccess.getPatternExpCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleLambdaLiteralExpCS
entryRuleLambdaLiteralExpCS
:
{ before(grammarAccess.getLambdaLiteralExpCSRule()); }
ruleLambdaLiteralExpCS
{ after(grammarAccess.getLambdaLiteralExpCSRule()); }
EOF
;
// Rule LambdaLiteralExpCS
ruleLambdaLiteralExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getLambdaLiteralExpCSAccess().getGroup()); }
(rule__LambdaLiteralExpCS__Group__0)
{ after(grammarAccess.getLambdaLiteralExpCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleMapLiteralExpCS
entryRuleMapLiteralExpCS
:
{ before(grammarAccess.getMapLiteralExpCSRule()); }
ruleMapLiteralExpCS
{ after(grammarAccess.getMapLiteralExpCSRule()); }
EOF
;
// Rule MapLiteralExpCS
ruleMapLiteralExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getMapLiteralExpCSAccess().getGroup()); }
(rule__MapLiteralExpCS__Group__0)
{ after(grammarAccess.getMapLiteralExpCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleMapLiteralPartCS
entryRuleMapLiteralPartCS
:
{ before(grammarAccess.getMapLiteralPartCSRule()); }
ruleMapLiteralPartCS
{ after(grammarAccess.getMapLiteralPartCSRule()); }
EOF
;
// Rule MapLiteralPartCS
ruleMapLiteralPartCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getMapLiteralPartCSAccess().getGroup()); }
(rule__MapLiteralPartCS__Group__0)
{ after(grammarAccess.getMapLiteralPartCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePrimitiveLiteralExpCS
entryRulePrimitiveLiteralExpCS
:
{ before(grammarAccess.getPrimitiveLiteralExpCSRule()); }
rulePrimitiveLiteralExpCS
{ after(grammarAccess.getPrimitiveLiteralExpCSRule()); }
EOF
;
// Rule PrimitiveLiteralExpCS
rulePrimitiveLiteralExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPrimitiveLiteralExpCSAccess().getAlternatives()); }
(rule__PrimitiveLiteralExpCS__Alternatives)
{ after(grammarAccess.getPrimitiveLiteralExpCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTupleLiteralExpCS
entryRuleTupleLiteralExpCS
:
{ before(grammarAccess.getTupleLiteralExpCSRule()); }
ruleTupleLiteralExpCS
{ after(grammarAccess.getTupleLiteralExpCSRule()); }
EOF
;
// Rule TupleLiteralExpCS
ruleTupleLiteralExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTupleLiteralExpCSAccess().getGroup()); }
(rule__TupleLiteralExpCS__Group__0)
{ after(grammarAccess.getTupleLiteralExpCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTupleLiteralPartCS
entryRuleTupleLiteralPartCS
:
{ before(grammarAccess.getTupleLiteralPartCSRule()); }
ruleTupleLiteralPartCS
{ after(grammarAccess.getTupleLiteralPartCSRule()); }
EOF
;
// Rule TupleLiteralPartCS
ruleTupleLiteralPartCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTupleLiteralPartCSAccess().getGroup()); }
(rule__TupleLiteralPartCS__Group__0)
{ after(grammarAccess.getTupleLiteralPartCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleNumberLiteralExpCS
entryRuleNumberLiteralExpCS
:
{ before(grammarAccess.getNumberLiteralExpCSRule()); }
ruleNumberLiteralExpCS
{ after(grammarAccess.getNumberLiteralExpCSRule()); }
EOF
;
// Rule NumberLiteralExpCS
ruleNumberLiteralExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getNumberLiteralExpCSAccess().getSymbolAssignment()); }
(rule__NumberLiteralExpCS__SymbolAssignment)
{ after(grammarAccess.getNumberLiteralExpCSAccess().getSymbolAssignment()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleStringLiteralExpCS
entryRuleStringLiteralExpCS
:
{ before(grammarAccess.getStringLiteralExpCSRule()); }
ruleStringLiteralExpCS
{ after(grammarAccess.getStringLiteralExpCSRule()); }
EOF
;
// Rule StringLiteralExpCS
ruleStringLiteralExpCS
@init {
int stackSize = keepStackSize();
}
:
(
(
{ before(grammarAccess.getStringLiteralExpCSAccess().getSegmentsAssignment()); }
(rule__StringLiteralExpCS__SegmentsAssignment)
{ after(grammarAccess.getStringLiteralExpCSAccess().getSegmentsAssignment()); }
)
(
{ before(grammarAccess.getStringLiteralExpCSAccess().getSegmentsAssignment()); }
(rule__StringLiteralExpCS__SegmentsAssignment)*
{ after(grammarAccess.getStringLiteralExpCSAccess().getSegmentsAssignment()); }
)
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleBooleanLiteralExpCS
entryRuleBooleanLiteralExpCS
:
{ before(grammarAccess.getBooleanLiteralExpCSRule()); }
ruleBooleanLiteralExpCS
{ after(grammarAccess.getBooleanLiteralExpCSRule()); }
EOF
;
// Rule BooleanLiteralExpCS
ruleBooleanLiteralExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getBooleanLiteralExpCSAccess().getAlternatives()); }
(rule__BooleanLiteralExpCS__Alternatives)
{ after(grammarAccess.getBooleanLiteralExpCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleUnlimitedNaturalLiteralExpCS
entryRuleUnlimitedNaturalLiteralExpCS
:
{ before(grammarAccess.getUnlimitedNaturalLiteralExpCSRule()); }
ruleUnlimitedNaturalLiteralExpCS
{ after(grammarAccess.getUnlimitedNaturalLiteralExpCSRule()); }
EOF
;
// Rule UnlimitedNaturalLiteralExpCS
ruleUnlimitedNaturalLiteralExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getGroup()); }
(rule__UnlimitedNaturalLiteralExpCS__Group__0)
{ after(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleInvalidLiteralExpCS
entryRuleInvalidLiteralExpCS
:
{ before(grammarAccess.getInvalidLiteralExpCSRule()); }
ruleInvalidLiteralExpCS
{ after(grammarAccess.getInvalidLiteralExpCSRule()); }
EOF
;
// Rule InvalidLiteralExpCS
ruleInvalidLiteralExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getInvalidLiteralExpCSAccess().getGroup()); }
(rule__InvalidLiteralExpCS__Group__0)
{ after(grammarAccess.getInvalidLiteralExpCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleNullLiteralExpCS
entryRuleNullLiteralExpCS
:
{ before(grammarAccess.getNullLiteralExpCSRule()); }
ruleNullLiteralExpCS
{ after(grammarAccess.getNullLiteralExpCSRule()); }
EOF
;
// Rule NullLiteralExpCS
ruleNullLiteralExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getNullLiteralExpCSAccess().getGroup()); }
(rule__NullLiteralExpCS__Group__0)
{ after(grammarAccess.getNullLiteralExpCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTypeLiteralCS
entryRuleTypeLiteralCS
:
{ before(grammarAccess.getTypeLiteralCSRule()); }
ruleTypeLiteralCS
{ after(grammarAccess.getTypeLiteralCSRule()); }
EOF
;
// Rule TypeLiteralCS
ruleTypeLiteralCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTypeLiteralCSAccess().getAlternatives()); }
(rule__TypeLiteralCS__Alternatives)
{ after(grammarAccess.getTypeLiteralCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTypeLiteralWithMultiplicityCS
entryRuleTypeLiteralWithMultiplicityCS
:
{ before(grammarAccess.getTypeLiteralWithMultiplicityCSRule()); }
ruleTypeLiteralWithMultiplicityCS
{ after(grammarAccess.getTypeLiteralWithMultiplicityCSRule()); }
EOF
;
// Rule TypeLiteralWithMultiplicityCS
ruleTypeLiteralWithMultiplicityCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getGroup()); }
(rule__TypeLiteralWithMultiplicityCS__Group__0)
{ after(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTypeLiteralExpCS
entryRuleTypeLiteralExpCS
:
{ before(grammarAccess.getTypeLiteralExpCSRule()); }
ruleTypeLiteralExpCS
{ after(grammarAccess.getTypeLiteralExpCSRule()); }
EOF
;
// Rule TypeLiteralExpCS
ruleTypeLiteralExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTypeLiteralExpCSAccess().getOwnedTypeAssignment()); }
(rule__TypeLiteralExpCS__OwnedTypeAssignment)
{ after(grammarAccess.getTypeLiteralExpCSAccess().getOwnedTypeAssignment()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTypeNameExpCS
entryRuleTypeNameExpCS
:
{ before(grammarAccess.getTypeNameExpCSRule()); }
ruleTypeNameExpCS
{ after(grammarAccess.getTypeNameExpCSRule()); }
EOF
;
// Rule TypeNameExpCS
ruleTypeNameExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTypeNameExpCSAccess().getGroup()); }
(rule__TypeNameExpCS__Group__0)
{ after(grammarAccess.getTypeNameExpCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTypeExpWithoutMultiplicityCS
entryRuleTypeExpWithoutMultiplicityCS
:
{ before(grammarAccess.getTypeExpWithoutMultiplicityCSRule()); }
ruleTypeExpWithoutMultiplicityCS
{ after(grammarAccess.getTypeExpWithoutMultiplicityCSRule()); }
EOF
;
// Rule TypeExpWithoutMultiplicityCS
ruleTypeExpWithoutMultiplicityCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getAlternatives()); }
(rule__TypeExpWithoutMultiplicityCS__Alternatives)
{ after(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTypeExpCS
entryRuleTypeExpCS
:
{ before(grammarAccess.getTypeExpCSRule()); }
ruleTypeExpCS
{ after(grammarAccess.getTypeExpCSRule()); }
EOF
;
// Rule TypeExpCS
ruleTypeExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTypeExpCSAccess().getGroup()); }
(rule__TypeExpCS__Group__0)
{ after(grammarAccess.getTypeExpCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleExpCS
entryRuleExpCS
:
{ before(grammarAccess.getExpCSRule()); }
ruleExpCS
{ after(grammarAccess.getExpCSRule()); }
EOF
;
// Rule ExpCS
ruleExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getExpCSAccess().getAlternatives()); }
(rule__ExpCS__Alternatives)
{ after(grammarAccess.getExpCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePrefixedLetExpCS
entryRulePrefixedLetExpCS
:
{ before(grammarAccess.getPrefixedLetExpCSRule()); }
rulePrefixedLetExpCS
{ after(grammarAccess.getPrefixedLetExpCSRule()); }
EOF
;
// Rule PrefixedLetExpCS
rulePrefixedLetExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPrefixedLetExpCSAccess().getAlternatives()); }
(rule__PrefixedLetExpCS__Alternatives)
{ after(grammarAccess.getPrefixedLetExpCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePrefixedPrimaryExpCS
entryRulePrefixedPrimaryExpCS
:
{ before(grammarAccess.getPrefixedPrimaryExpCSRule()); }
rulePrefixedPrimaryExpCS
{ after(grammarAccess.getPrefixedPrimaryExpCSRule()); }
EOF
;
// Rule PrefixedPrimaryExpCS
rulePrefixedPrimaryExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPrefixedPrimaryExpCSAccess().getAlternatives()); }
(rule__PrefixedPrimaryExpCS__Alternatives)
{ after(grammarAccess.getPrefixedPrimaryExpCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePrimaryExpCS
entryRulePrimaryExpCS
:
{ before(grammarAccess.getPrimaryExpCSRule()); }
rulePrimaryExpCS
{ after(grammarAccess.getPrimaryExpCSRule()); }
EOF
;
// Rule PrimaryExpCS
rulePrimaryExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPrimaryExpCSAccess().getAlternatives()); }
(rule__PrimaryExpCS__Alternatives)
{ after(grammarAccess.getPrimaryExpCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleNameExpCS
entryRuleNameExpCS
:
{ before(grammarAccess.getNameExpCSRule()); }
ruleNameExpCS
{ after(grammarAccess.getNameExpCSRule()); }
EOF
;
// Rule NameExpCS
ruleNameExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getNameExpCSAccess().getGroup()); }
(rule__NameExpCS__Group__0)
{ after(grammarAccess.getNameExpCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleCurlyBracketedClauseCS
entryRuleCurlyBracketedClauseCS
:
{ before(grammarAccess.getCurlyBracketedClauseCSRule()); }
ruleCurlyBracketedClauseCS
{ after(grammarAccess.getCurlyBracketedClauseCSRule()); }
EOF
;
// Rule CurlyBracketedClauseCS
ruleCurlyBracketedClauseCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup()); }
(rule__CurlyBracketedClauseCS__Group__0)
{ after(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleRoundBracketedClauseCS
entryRuleRoundBracketedClauseCS
:
{ before(grammarAccess.getRoundBracketedClauseCSRule()); }
ruleRoundBracketedClauseCS
{ after(grammarAccess.getRoundBracketedClauseCSRule()); }
EOF
;
// Rule RoundBracketedClauseCS
ruleRoundBracketedClauseCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getRoundBracketedClauseCSAccess().getGroup()); }
(rule__RoundBracketedClauseCS__Group__0)
{ after(grammarAccess.getRoundBracketedClauseCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleSquareBracketedClauseCS
entryRuleSquareBracketedClauseCS
:
{ before(grammarAccess.getSquareBracketedClauseCSRule()); }
ruleSquareBracketedClauseCS
{ after(grammarAccess.getSquareBracketedClauseCSRule()); }
EOF
;
// Rule SquareBracketedClauseCS
ruleSquareBracketedClauseCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getSquareBracketedClauseCSAccess().getGroup()); }
(rule__SquareBracketedClauseCS__Group__0)
{ after(grammarAccess.getSquareBracketedClauseCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleNavigatingArgCS
entryRuleNavigatingArgCS
:
{ before(grammarAccess.getNavigatingArgCSRule()); }
ruleNavigatingArgCS
{ after(grammarAccess.getNavigatingArgCSRule()); }
EOF
;
// Rule NavigatingArgCS
ruleNavigatingArgCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getNavigatingArgCSAccess().getAlternatives()); }
(rule__NavigatingArgCS__Alternatives)
{ after(grammarAccess.getNavigatingArgCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleNavigatingBarArgCS
entryRuleNavigatingBarArgCS
:
{ before(grammarAccess.getNavigatingBarArgCSRule()); }
ruleNavigatingBarArgCS
{ after(grammarAccess.getNavigatingBarArgCSRule()); }
EOF
;
// Rule NavigatingBarArgCS
ruleNavigatingBarArgCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getNavigatingBarArgCSAccess().getGroup()); }
(rule__NavigatingBarArgCS__Group__0)
{ after(grammarAccess.getNavigatingBarArgCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleNavigatingCommaArgCS
entryRuleNavigatingCommaArgCS
:
{ before(grammarAccess.getNavigatingCommaArgCSRule()); }
ruleNavigatingCommaArgCS
{ after(grammarAccess.getNavigatingCommaArgCSRule()); }
EOF
;
// Rule NavigatingCommaArgCS
ruleNavigatingCommaArgCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup()); }
(rule__NavigatingCommaArgCS__Group__0)
{ after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleNavigatingSemiArgCS
entryRuleNavigatingSemiArgCS
:
{ before(grammarAccess.getNavigatingSemiArgCSRule()); }
ruleNavigatingSemiArgCS
{ after(grammarAccess.getNavigatingSemiArgCSRule()); }
EOF
;
// Rule NavigatingSemiArgCS
ruleNavigatingSemiArgCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getNavigatingSemiArgCSAccess().getGroup()); }
(rule__NavigatingSemiArgCS__Group__0)
{ after(grammarAccess.getNavigatingSemiArgCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleNavigatingArgExpCS
entryRuleNavigatingArgExpCS
:
{ before(grammarAccess.getNavigatingArgExpCSRule()); }
ruleNavigatingArgExpCS
{ after(grammarAccess.getNavigatingArgExpCSRule()); }
EOF
;
// Rule NavigatingArgExpCS
ruleNavigatingArgExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getNavigatingArgExpCSAccess().getExpCSParserRuleCall()); }
ruleExpCS
{ after(grammarAccess.getNavigatingArgExpCSAccess().getExpCSParserRuleCall()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleCoIteratorVariableCS
entryRuleCoIteratorVariableCS
:
{ before(grammarAccess.getCoIteratorVariableCSRule()); }
ruleCoIteratorVariableCS
{ after(grammarAccess.getCoIteratorVariableCSRule()); }
EOF
;
// Rule CoIteratorVariableCS
ruleCoIteratorVariableCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getCoIteratorVariableCSAccess().getGroup()); }
(rule__CoIteratorVariableCS__Group__0)
{ after(grammarAccess.getCoIteratorVariableCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleIfExpCS
entryRuleIfExpCS
:
{ before(grammarAccess.getIfExpCSRule()); }
ruleIfExpCS
{ after(grammarAccess.getIfExpCSRule()); }
EOF
;
// Rule IfExpCS
ruleIfExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getIfExpCSAccess().getGroup()); }
(rule__IfExpCS__Group__0)
{ after(grammarAccess.getIfExpCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleElseIfThenExpCS
entryRuleElseIfThenExpCS
:
{ before(grammarAccess.getElseIfThenExpCSRule()); }
ruleElseIfThenExpCS
{ after(grammarAccess.getElseIfThenExpCSRule()); }
EOF
;
// Rule ElseIfThenExpCS
ruleElseIfThenExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getElseIfThenExpCSAccess().getGroup()); }
(rule__ElseIfThenExpCS__Group__0)
{ after(grammarAccess.getElseIfThenExpCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleLetExpCS
entryRuleLetExpCS
:
{ before(grammarAccess.getLetExpCSRule()); }
ruleLetExpCS
{ after(grammarAccess.getLetExpCSRule()); }
EOF
;
// Rule LetExpCS
ruleLetExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getLetExpCSAccess().getGroup()); }
(rule__LetExpCS__Group__0)
{ after(grammarAccess.getLetExpCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleLetVariableCS
entryRuleLetVariableCS
:
{ before(grammarAccess.getLetVariableCSRule()); }
ruleLetVariableCS
{ after(grammarAccess.getLetVariableCSRule()); }
EOF
;
// Rule LetVariableCS
ruleLetVariableCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getLetVariableCSAccess().getGroup()); }
(rule__LetVariableCS__Group__0)
{ after(grammarAccess.getLetVariableCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleNestedExpCS
entryRuleNestedExpCS
:
{ before(grammarAccess.getNestedExpCSRule()); }
ruleNestedExpCS
{ after(grammarAccess.getNestedExpCSRule()); }
EOF
;
// Rule NestedExpCS
ruleNestedExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getNestedExpCSAccess().getGroup()); }
(rule__NestedExpCS__Group__0)
{ after(grammarAccess.getNestedExpCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleSelfExpCS
entryRuleSelfExpCS
:
{ before(grammarAccess.getSelfExpCSRule()); }
ruleSelfExpCS
{ after(grammarAccess.getSelfExpCSRule()); }
EOF
;
// Rule SelfExpCS
ruleSelfExpCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getSelfExpCSAccess().getGroup()); }
(rule__SelfExpCS__Group__0)
{ after(grammarAccess.getSelfExpCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleMultiplicityBoundsCS
entryRuleMultiplicityBoundsCS
:
{ before(grammarAccess.getMultiplicityBoundsCSRule()); }
ruleMultiplicityBoundsCS
{ after(grammarAccess.getMultiplicityBoundsCSRule()); }
EOF
;
// Rule MultiplicityBoundsCS
ruleMultiplicityBoundsCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getMultiplicityBoundsCSAccess().getGroup()); }
(rule__MultiplicityBoundsCS__Group__0)
{ after(grammarAccess.getMultiplicityBoundsCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleMultiplicityCS
entryRuleMultiplicityCS
:
{ before(grammarAccess.getMultiplicityCSRule()); }
ruleMultiplicityCS
{ after(grammarAccess.getMultiplicityCSRule()); }
EOF
;
// Rule MultiplicityCS
ruleMultiplicityCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getMultiplicityCSAccess().getGroup()); }
(rule__MultiplicityCS__Group__0)
{ after(grammarAccess.getMultiplicityCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleMultiplicityStringCS
entryRuleMultiplicityStringCS
:
{ before(grammarAccess.getMultiplicityStringCSRule()); }
ruleMultiplicityStringCS
{ after(grammarAccess.getMultiplicityStringCSRule()); }
EOF
;
// Rule MultiplicityStringCS
ruleMultiplicityStringCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAssignment()); }
(rule__MultiplicityStringCS__StringBoundsAssignment)
{ after(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAssignment()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePathNameCS
entryRulePathNameCS
:
{ before(grammarAccess.getPathNameCSRule()); }
rulePathNameCS
{ after(grammarAccess.getPathNameCSRule()); }
EOF
;
// Rule PathNameCS
rulePathNameCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPathNameCSAccess().getGroup()); }
(rule__PathNameCS__Group__0)
{ after(grammarAccess.getPathNameCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleFirstPathElementCS
entryRuleFirstPathElementCS
:
{ before(grammarAccess.getFirstPathElementCSRule()); }
ruleFirstPathElementCS
{ after(grammarAccess.getFirstPathElementCSRule()); }
EOF
;
// Rule FirstPathElementCS
ruleFirstPathElementCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getFirstPathElementCSAccess().getReferredElementAssignment()); }
(rule__FirstPathElementCS__ReferredElementAssignment)
{ after(grammarAccess.getFirstPathElementCSAccess().getReferredElementAssignment()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleNextPathElementCS
entryRuleNextPathElementCS
:
{ before(grammarAccess.getNextPathElementCSRule()); }
ruleNextPathElementCS
{ after(grammarAccess.getNextPathElementCSRule()); }
EOF
;
// Rule NextPathElementCS
ruleNextPathElementCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getNextPathElementCSAccess().getReferredElementAssignment()); }
(rule__NextPathElementCS__ReferredElementAssignment)
{ after(grammarAccess.getNextPathElementCSAccess().getReferredElementAssignment()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTemplateBindingCS
entryRuleTemplateBindingCS
:
{ before(grammarAccess.getTemplateBindingCSRule()); }
ruleTemplateBindingCS
{ after(grammarAccess.getTemplateBindingCSRule()); }
EOF
;
// Rule TemplateBindingCS
ruleTemplateBindingCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTemplateBindingCSAccess().getGroup()); }
(rule__TemplateBindingCS__Group__0)
{ after(grammarAccess.getTemplateBindingCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTemplateParameterSubstitutionCS
entryRuleTemplateParameterSubstitutionCS
:
{ before(grammarAccess.getTemplateParameterSubstitutionCSRule()); }
ruleTemplateParameterSubstitutionCS
{ after(grammarAccess.getTemplateParameterSubstitutionCSRule()); }
EOF
;
// Rule TemplateParameterSubstitutionCS
ruleTemplateParameterSubstitutionCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTemplateParameterSubstitutionCSAccess().getOwnedActualParameterAssignment()); }
(rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment)
{ after(grammarAccess.getTemplateParameterSubstitutionCSAccess().getOwnedActualParameterAssignment()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTypeParameterCS
entryRuleTypeParameterCS
:
{ before(grammarAccess.getTypeParameterCSRule()); }
ruleTypeParameterCS
{ after(grammarAccess.getTypeParameterCSRule()); }
EOF
;
// Rule TypeParameterCS
ruleTypeParameterCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTypeParameterCSAccess().getGroup()); }
(rule__TypeParameterCS__Group__0)
{ after(grammarAccess.getTypeParameterCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTypeRefCS
entryRuleTypeRefCS
:
{ before(grammarAccess.getTypeRefCSRule()); }
ruleTypeRefCS
{ after(grammarAccess.getTypeRefCSRule()); }
EOF
;
// Rule TypeRefCS
ruleTypeRefCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTypeRefCSAccess().getAlternatives()); }
(rule__TypeRefCS__Alternatives)
{ after(grammarAccess.getTypeRefCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTypedRefCS
entryRuleTypedRefCS
:
{ before(grammarAccess.getTypedRefCSRule()); }
ruleTypedRefCS
{ after(grammarAccess.getTypedRefCSRule()); }
EOF
;
// Rule TypedRefCS
ruleTypedRefCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTypedRefCSAccess().getTypedTypeRefCSParserRuleCall()); }
ruleTypedTypeRefCS
{ after(grammarAccess.getTypedRefCSAccess().getTypedTypeRefCSParserRuleCall()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTypedTypeRefCS
entryRuleTypedTypeRefCS
:
{ before(grammarAccess.getTypedTypeRefCSRule()); }
ruleTypedTypeRefCS
{ after(grammarAccess.getTypedTypeRefCSRule()); }
EOF
;
// Rule TypedTypeRefCS
ruleTypedTypeRefCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTypedTypeRefCSAccess().getGroup()); }
(rule__TypedTypeRefCS__Group__0)
{ after(grammarAccess.getTypedTypeRefCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleWildcardTypeRefCS
entryRuleWildcardTypeRefCS
:
{ before(grammarAccess.getWildcardTypeRefCSRule()); }
ruleWildcardTypeRefCS
{ after(grammarAccess.getWildcardTypeRefCSRule()); }
EOF
;
// Rule WildcardTypeRefCS
ruleWildcardTypeRefCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getWildcardTypeRefCSAccess().getGroup()); }
(rule__WildcardTypeRefCS__Group__0)
{ after(grammarAccess.getWildcardTypeRefCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleID
entryRuleID
:
{ before(grammarAccess.getIDRule()); }
ruleID
{ after(grammarAccess.getIDRule()); }
EOF
;
// Rule ID
ruleID
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getIDAccess().getAlternatives()); }
(rule__ID__Alternatives)
{ after(grammarAccess.getIDAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleIdentifier
entryRuleIdentifier
:
{ before(grammarAccess.getIdentifierRule()); }
ruleIdentifier
{ after(grammarAccess.getIdentifierRule()); }
EOF
;
// Rule Identifier
ruleIdentifier
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getIdentifierAccess().getIDParserRuleCall()); }
ruleID
{ after(grammarAccess.getIdentifierAccess().getIDParserRuleCall()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleLOWER
entryRuleLOWER
:
{ before(grammarAccess.getLOWERRule()); }
ruleLOWER
{ after(grammarAccess.getLOWERRule()); }
EOF
;
// Rule LOWER
ruleLOWER
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getLOWERAccess().getINTTerminalRuleCall()); }
RULE_INT
{ after(grammarAccess.getLOWERAccess().getINTTerminalRuleCall()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleNUMBER_LITERAL
entryRuleNUMBER_LITERAL
:
{ before(grammarAccess.getNUMBER_LITERALRule()); }
ruleNUMBER_LITERAL
{ after(grammarAccess.getNUMBER_LITERALRule()); }
EOF
;
// Rule NUMBER_LITERAL
ruleNUMBER_LITERAL
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getNUMBER_LITERALAccess().getINTTerminalRuleCall()); }
RULE_INT
{ after(grammarAccess.getNUMBER_LITERALAccess().getINTTerminalRuleCall()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleStringLiteral
entryRuleStringLiteral
:
{ before(grammarAccess.getStringLiteralRule()); }
ruleStringLiteral
{ after(grammarAccess.getStringLiteralRule()); }
EOF
;
// Rule StringLiteral
ruleStringLiteral
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getStringLiteralAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall()); }
RULE_SINGLE_QUOTED_STRING
{ after(grammarAccess.getStringLiteralAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleUPPER
entryRuleUPPER
:
{ before(grammarAccess.getUPPERRule()); }
ruleUPPER
{ after(grammarAccess.getUPPERRule()); }
EOF
;
// Rule UPPER
ruleUPPER
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getUPPERAccess().getAlternatives()); }
(rule__UPPER__Alternatives)
{ after(grammarAccess.getUPPERAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleURI
entryRuleURI
:
{ before(grammarAccess.getURIRule()); }
ruleURI
{ after(grammarAccess.getURIRule()); }
EOF
;
// Rule URI
ruleURI
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getURIAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall()); }
RULE_SINGLE_QUOTED_STRING
{ after(grammarAccess.getURIAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__EssentialOCLUnaryOperatorName__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getHyphenMinusKeyword_0()); }
'-'
{ after(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getHyphenMinusKeyword_0()); }
)
|(
{ before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNotKeyword_1()); }
'not'
{ after(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNotKeyword_1()); }
)
|(
{ before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNot2Keyword_2()); }
'not2'
{ after(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNot2Keyword_2()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__EssentialOCLInfixOperatorName__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAsteriskKeyword_0()); }
'*'
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAsteriskKeyword_0()); }
)
|(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getSolidusKeyword_1()); }
'/'
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getSolidusKeyword_1()); }
)
|(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getPlusSignKeyword_2()); }
'+'
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getPlusSignKeyword_2()); }
)
|(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getHyphenMinusKeyword_3()); }
'-'
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getHyphenMinusKeyword_3()); }
)
|(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignKeyword_4()); }
'>'
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignKeyword_4()); }
)
|(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignKeyword_5()); }
'<'
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignKeyword_5()); }
)
|(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignEqualsSignKeyword_6()); }
'>='
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignEqualsSignKeyword_6()); }
)
|(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignEqualsSignKeyword_7()); }
'<='
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignEqualsSignKeyword_7()); }
)
|(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getEqualsSignKeyword_8()); }
'='
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getEqualsSignKeyword_8()); }
)
|(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignGreaterThanSignKeyword_9()); }
'<>'
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignGreaterThanSignKeyword_9()); }
)
|(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAndKeyword_10()); }
'and'
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAndKeyword_10()); }
)
|(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAnd2Keyword_11()); }
'and2'
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAnd2Keyword_11()); }
)
|(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImpliesKeyword_12()); }
'implies'
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImpliesKeyword_12()); }
)
|(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImplies2Keyword_13()); }
'implies2'
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImplies2Keyword_13()); }
)
|(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOrKeyword_14()); }
'or'
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOrKeyword_14()); }
)
|(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOr2Keyword_15()); }
'or2'
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOr2Keyword_15()); }
)
|(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXorKeyword_16()); }
'xor'
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXorKeyword_16()); }
)
|(
{ before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXor2Keyword_17()); }
'xor2'
{ after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXor2Keyword_17()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__EssentialOCLNavigationOperatorName__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getFullStopKeyword_0()); }
'.'
{ after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getFullStopKeyword_0()); }
)
|(
{ before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getHyphenMinusGreaterThanSignKeyword_1()); }
'->'
{ after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getHyphenMinusGreaterThanSignKeyword_1()); }
)
|(
{ before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkFullStopKeyword_2()); }
'?.'
{ after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkFullStopKeyword_2()); }
)
|(
{ before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkHyphenMinusGreaterThanSignKeyword_3()); }
'?->'
{ after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkHyphenMinusGreaterThanSignKeyword_3()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__BinaryOperatorName__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getBinaryOperatorNameAccess().getInfixOperatorNameParserRuleCall_0()); }
ruleInfixOperatorName
{ after(grammarAccess.getBinaryOperatorNameAccess().getInfixOperatorNameParserRuleCall_0()); }
)
|(
{ before(grammarAccess.getBinaryOperatorNameAccess().getNavigationOperatorNameParserRuleCall_1()); }
ruleNavigationOperatorName
{ after(grammarAccess.getBinaryOperatorNameAccess().getNavigationOperatorNameParserRuleCall_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__EssentialOCLUnreservedName__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getEssentialOCLUnreservedNameAccess().getUnrestrictedNameParserRuleCall_0()); }
ruleUnrestrictedName
{ after(grammarAccess.getEssentialOCLUnreservedNameAccess().getUnrestrictedNameParserRuleCall_0()); }
)
|(
{ before(grammarAccess.getEssentialOCLUnreservedNameAccess().getCollectionTypeIdentifierParserRuleCall_1()); }
ruleCollectionTypeIdentifier
{ after(grammarAccess.getEssentialOCLUnreservedNameAccess().getCollectionTypeIdentifierParserRuleCall_1()); }
)
|(
{ before(grammarAccess.getEssentialOCLUnreservedNameAccess().getPrimitiveTypeIdentifierParserRuleCall_2()); }
rulePrimitiveTypeIdentifier
{ after(grammarAccess.getEssentialOCLUnreservedNameAccess().getPrimitiveTypeIdentifierParserRuleCall_2()); }
)
|(
{ before(grammarAccess.getEssentialOCLUnreservedNameAccess().getMapKeyword_3()); }
'Map'
{ after(grammarAccess.getEssentialOCLUnreservedNameAccess().getMapKeyword_3()); }
)
|(
{ before(grammarAccess.getEssentialOCLUnreservedNameAccess().getTupleKeyword_4()); }
'Tuple'
{ after(grammarAccess.getEssentialOCLUnreservedNameAccess().getTupleKeyword_4()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__URIFirstPathElementCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementAssignment_0()); }
(rule__URIFirstPathElementCS__ReferredElementAssignment_0)
{ after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementAssignment_0()); }
)
|(
{ before(grammarAccess.getURIFirstPathElementCSAccess().getGroup_1()); }
(rule__URIFirstPathElementCS__Group_1__0)
{ after(grammarAccess.getURIFirstPathElementCSAccess().getGroup_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__PrimitiveTypeIdentifier__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPrimitiveTypeIdentifierAccess().getBooleanKeyword_0()); }
'Boolean'
{ after(grammarAccess.getPrimitiveTypeIdentifierAccess().getBooleanKeyword_0()); }
)
|(
{ before(grammarAccess.getPrimitiveTypeIdentifierAccess().getIntegerKeyword_1()); }
'Integer'
{ after(grammarAccess.getPrimitiveTypeIdentifierAccess().getIntegerKeyword_1()); }
)
|(
{ before(grammarAccess.getPrimitiveTypeIdentifierAccess().getRealKeyword_2()); }
'Real'
{ after(grammarAccess.getPrimitiveTypeIdentifierAccess().getRealKeyword_2()); }
)
|(
{ before(grammarAccess.getPrimitiveTypeIdentifierAccess().getStringKeyword_3()); }
'String'
{ after(grammarAccess.getPrimitiveTypeIdentifierAccess().getStringKeyword_3()); }
)
|(
{ before(grammarAccess.getPrimitiveTypeIdentifierAccess().getUnlimitedNaturalKeyword_4()); }
'UnlimitedNatural'
{ after(grammarAccess.getPrimitiveTypeIdentifierAccess().getUnlimitedNaturalKeyword_4()); }
)
|(
{ before(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclAnyKeyword_5()); }
'OclAny'
{ after(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclAnyKeyword_5()); }
)
|(
{ before(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclInvalidKeyword_6()); }
'OclInvalid'
{ after(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclInvalidKeyword_6()); }
)
|(
{ before(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclVoidKeyword_7()); }
'OclVoid'
{ after(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclVoidKeyword_7()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__CollectionTypeIdentifier__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getCollectionTypeIdentifierAccess().getSetKeyword_0()); }
'Set'
{ after(grammarAccess.getCollectionTypeIdentifierAccess().getSetKeyword_0()); }
)
|(
{ before(grammarAccess.getCollectionTypeIdentifierAccess().getBagKeyword_1()); }
'Bag'
{ after(grammarAccess.getCollectionTypeIdentifierAccess().getBagKeyword_1()); }
)
|(
{ before(grammarAccess.getCollectionTypeIdentifierAccess().getSequenceKeyword_2()); }
'Sequence'
{ after(grammarAccess.getCollectionTypeIdentifierAccess().getSequenceKeyword_2()); }
)
|(
{ before(grammarAccess.getCollectionTypeIdentifierAccess().getCollectionKeyword_3()); }
'Collection'
{ after(grammarAccess.getCollectionTypeIdentifierAccess().getCollectionKeyword_3()); }
)
|(
{ before(grammarAccess.getCollectionTypeIdentifierAccess().getOrderedSetKeyword_4()); }
'OrderedSet'
{ after(grammarAccess.getCollectionTypeIdentifierAccess().getOrderedSetKeyword_4()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__CollectionLiteralPartCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_0()); }
(rule__CollectionLiteralPartCS__Group_0__0)
{ after(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_0()); }
)
|(
{ before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionAssignment_1()); }
(rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1)
{ after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionAssignment_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__ShadowPartCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getShadowPartCSAccess().getGroup_0()); }
(rule__ShadowPartCS__Group_0__0)
{ after(grammarAccess.getShadowPartCSAccess().getGroup_0()); }
)
|(
{ before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAssignment_1()); }
(rule__ShadowPartCS__OwnedInitExpressionAssignment_1)
{ after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAssignment_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_2_0_0()); }
ruleExpCS
{ after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_2_0_0()); }
)
|(
{ before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionPatternExpCSParserRuleCall_0_2_0_1()); }
rulePatternExpCS
{ after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionPatternExpCSParserRuleCall_0_2_0_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__MapLiteralPartCS__Alternatives_1
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getMapLiteralPartCSAccess().getWithKeyword_1_0()); }
'with'
{ after(grammarAccess.getMapLiteralPartCSAccess().getWithKeyword_1_0()); }
)
|(
{ before(grammarAccess.getMapLiteralPartCSAccess().getLessThanSignHyphenMinusKeyword_1_1()); }
'<-'
{ after(grammarAccess.getMapLiteralPartCSAccess().getLessThanSignHyphenMinusKeyword_1_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__PrimitiveLiteralExpCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPrimitiveLiteralExpCSAccess().getNumberLiteralExpCSParserRuleCall_0()); }
ruleNumberLiteralExpCS
{ after(grammarAccess.getPrimitiveLiteralExpCSAccess().getNumberLiteralExpCSParserRuleCall_0()); }
)
|(
{ before(grammarAccess.getPrimitiveLiteralExpCSAccess().getStringLiteralExpCSParserRuleCall_1()); }
ruleStringLiteralExpCS
{ after(grammarAccess.getPrimitiveLiteralExpCSAccess().getStringLiteralExpCSParserRuleCall_1()); }
)
|(
{ before(grammarAccess.getPrimitiveLiteralExpCSAccess().getBooleanLiteralExpCSParserRuleCall_2()); }
ruleBooleanLiteralExpCS
{ after(grammarAccess.getPrimitiveLiteralExpCSAccess().getBooleanLiteralExpCSParserRuleCall_2()); }
)
|(
{ before(grammarAccess.getPrimitiveLiteralExpCSAccess().getUnlimitedNaturalLiteralExpCSParserRuleCall_3()); }
ruleUnlimitedNaturalLiteralExpCS
{ after(grammarAccess.getPrimitiveLiteralExpCSAccess().getUnlimitedNaturalLiteralExpCSParserRuleCall_3()); }
)
|(
{ before(grammarAccess.getPrimitiveLiteralExpCSAccess().getInvalidLiteralExpCSParserRuleCall_4()); }
ruleInvalidLiteralExpCS
{ after(grammarAccess.getPrimitiveLiteralExpCSAccess().getInvalidLiteralExpCSParserRuleCall_4()); }
)
|(
{ before(grammarAccess.getPrimitiveLiteralExpCSAccess().getNullLiteralExpCSParserRuleCall_5()); }
ruleNullLiteralExpCS
{ after(grammarAccess.getPrimitiveLiteralExpCSAccess().getNullLiteralExpCSParserRuleCall_5()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__BooleanLiteralExpCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_0()); }
(rule__BooleanLiteralExpCS__SymbolAssignment_0)
{ after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_0()); }
)
|(
{ before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_1()); }
(rule__BooleanLiteralExpCS__SymbolAssignment_1)
{ after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__TypeLiteralCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTypeLiteralCSAccess().getPrimitiveTypeCSParserRuleCall_0()); }
rulePrimitiveTypeCS
{ after(grammarAccess.getTypeLiteralCSAccess().getPrimitiveTypeCSParserRuleCall_0()); }
)
|(
{ before(grammarAccess.getTypeLiteralCSAccess().getCollectionTypeCSParserRuleCall_1()); }
ruleCollectionTypeCS
{ after(grammarAccess.getTypeLiteralCSAccess().getCollectionTypeCSParserRuleCall_1()); }
)
|(
{ before(grammarAccess.getTypeLiteralCSAccess().getMapTypeCSParserRuleCall_2()); }
ruleMapTypeCS
{ after(grammarAccess.getTypeLiteralCSAccess().getMapTypeCSParserRuleCall_2()); }
)
|(
{ before(grammarAccess.getTypeLiteralCSAccess().getTupleTypeCSParserRuleCall_3()); }
ruleTupleTypeCS
{ after(grammarAccess.getTypeLiteralCSAccess().getTupleTypeCSParserRuleCall_3()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__TypeExpWithoutMultiplicityCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeNameExpCSParserRuleCall_0()); }
ruleTypeNameExpCS
{ after(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeNameExpCSParserRuleCall_0()); }
)
|(
{ before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_1()); }
ruleTypeLiteralCS
{ after(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_1()); }
)
|(
{ before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getCollectionPatternCSParserRuleCall_2()); }
ruleCollectionPatternCS
{ after(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getCollectionPatternCSParserRuleCall_2()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__ExpCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getExpCSAccess().getGroup_0()); }
(rule__ExpCS__Group_0__0)
{ after(grammarAccess.getExpCSAccess().getGroup_0()); }
)
|(
{ before(grammarAccess.getExpCSAccess().getPrefixedLetExpCSParserRuleCall_1()); }
rulePrefixedLetExpCS
{ after(grammarAccess.getExpCSAccess().getPrefixedLetExpCSParserRuleCall_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__PrefixedLetExpCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPrefixedLetExpCSAccess().getGroup_0()); }
(rule__PrefixedLetExpCS__Group_0__0)
{ after(grammarAccess.getPrefixedLetExpCSAccess().getGroup_0()); }
)
|(
{ before(grammarAccess.getPrefixedLetExpCSAccess().getLetExpCSParserRuleCall_1()); }
ruleLetExpCS
{ after(grammarAccess.getPrefixedLetExpCSAccess().getLetExpCSParserRuleCall_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__PrefixedPrimaryExpCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPrefixedPrimaryExpCSAccess().getGroup_0()); }
(rule__PrefixedPrimaryExpCS__Group_0__0)
{ after(grammarAccess.getPrefixedPrimaryExpCSAccess().getGroup_0()); }
)
|(
{ before(grammarAccess.getPrefixedPrimaryExpCSAccess().getPrimaryExpCSParserRuleCall_1()); }
rulePrimaryExpCS
{ after(grammarAccess.getPrefixedPrimaryExpCSAccess().getPrimaryExpCSParserRuleCall_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__PrimaryExpCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPrimaryExpCSAccess().getNestedExpCSParserRuleCall_0()); }
ruleNestedExpCS
{ after(grammarAccess.getPrimaryExpCSAccess().getNestedExpCSParserRuleCall_0()); }
)
|(
{ before(grammarAccess.getPrimaryExpCSAccess().getIfExpCSParserRuleCall_1()); }
ruleIfExpCS
{ after(grammarAccess.getPrimaryExpCSAccess().getIfExpCSParserRuleCall_1()); }
)
|(
{ before(grammarAccess.getPrimaryExpCSAccess().getSelfExpCSParserRuleCall_2()); }
ruleSelfExpCS
{ after(grammarAccess.getPrimaryExpCSAccess().getSelfExpCSParserRuleCall_2()); }
)
|(
{ before(grammarAccess.getPrimaryExpCSAccess().getPrimitiveLiteralExpCSParserRuleCall_3()); }
rulePrimitiveLiteralExpCS
{ after(grammarAccess.getPrimaryExpCSAccess().getPrimitiveLiteralExpCSParserRuleCall_3()); }
)
|(
{ before(grammarAccess.getPrimaryExpCSAccess().getTupleLiteralExpCSParserRuleCall_4()); }
ruleTupleLiteralExpCS
{ after(grammarAccess.getPrimaryExpCSAccess().getTupleLiteralExpCSParserRuleCall_4()); }
)
|(
{ before(grammarAccess.getPrimaryExpCSAccess().getMapLiteralExpCSParserRuleCall_5()); }
ruleMapLiteralExpCS
{ after(grammarAccess.getPrimaryExpCSAccess().getMapLiteralExpCSParserRuleCall_5()); }
)
|(
{ before(grammarAccess.getPrimaryExpCSAccess().getCollectionLiteralExpCSParserRuleCall_6()); }
ruleCollectionLiteralExpCS
{ after(grammarAccess.getPrimaryExpCSAccess().getCollectionLiteralExpCSParserRuleCall_6()); }
)
|(
{ before(grammarAccess.getPrimaryExpCSAccess().getLambdaLiteralExpCSParserRuleCall_7()); }
ruleLambdaLiteralExpCS
{ after(grammarAccess.getPrimaryExpCSAccess().getLambdaLiteralExpCSParserRuleCall_7()); }
)
|(
{ before(grammarAccess.getPrimaryExpCSAccess().getTypeLiteralExpCSParserRuleCall_8()); }
ruleTypeLiteralExpCS
{ after(grammarAccess.getPrimaryExpCSAccess().getTypeLiteralExpCSParserRuleCall_8()); }
)
|(
{ before(grammarAccess.getPrimaryExpCSAccess().getNameExpCSParserRuleCall_9()); }
ruleNameExpCS
{ after(grammarAccess.getPrimaryExpCSAccess().getNameExpCSParserRuleCall_9()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingCommaArgCSParserRuleCall_2_1_0_0()); }
ruleNavigatingCommaArgCS
{ after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingCommaArgCSParserRuleCall_2_1_0_0()); }
)
|(
{ before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingSemiArgCSParserRuleCall_2_1_0_1()); }
ruleNavigatingSemiArgCS
{ after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingSemiArgCSParserRuleCall_2_1_0_1()); }
)
|(
{ before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingBarArgCSParserRuleCall_2_1_0_2()); }
ruleNavigatingBarArgCS
{ after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingBarArgCSParserRuleCall_2_1_0_2()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__NavigatingArgCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getNavigatingArgCSAccess().getGroup_0()); }
(rule__NavigatingArgCS__Group_0__0)
{ after(grammarAccess.getNavigatingArgCSAccess().getGroup_0()); }
)
|(
{ before(grammarAccess.getNavigatingArgCSAccess().getGroup_1()); }
(rule__NavigatingArgCS__Group_1__0)
{ after(grammarAccess.getNavigatingArgCSAccess().getGroup_1()); }
)