blob: 60931f1bfd4fa6cd923852ee98e81fd8eac30afb [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 InternalCompleteOCL;
options {
superClass=AbstractInternalContentAssistParser;
backtrack=true;
}
@lexer::header {
package org.eclipse.ocl.xtext.completeocl.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.completeocl.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.completeocl.services.CompleteOCLGrammarAccess;
}
@parser::members {
private CompleteOCLGrammarAccess grammarAccess;
public void setGrammarAccess(CompleteOCLGrammarAccess grammarAccess) {
this.grammarAccess = grammarAccess;
}
@Override
protected Grammar getGrammar() {
return grammarAccess.getGrammar();
}
@Override
protected String getValueForTokenName(String tokenName) {
return tokenName;
}
}
// Entry rule entryRuleCompleteOCLDocumentCS
entryRuleCompleteOCLDocumentCS
:
{ before(grammarAccess.getCompleteOCLDocumentCSRule()); }
ruleCompleteOCLDocumentCS
{ after(grammarAccess.getCompleteOCLDocumentCSRule()); }
EOF
;
// Rule CompleteOCLDocumentCS
ruleCompleteOCLDocumentCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getCompleteOCLDocumentCSAccess().getGroup()); }
(rule__CompleteOCLDocumentCS__Group__0)
{ after(grammarAccess.getCompleteOCLDocumentCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleCompleteOCLNavigationOperatorName
entryRuleCompleteOCLNavigationOperatorName
:
{ before(grammarAccess.getCompleteOCLNavigationOperatorNameRule()); }
ruleCompleteOCLNavigationOperatorName
{ after(grammarAccess.getCompleteOCLNavigationOperatorNameRule()); }
EOF
;
// Rule CompleteOCLNavigationOperatorName
ruleCompleteOCLNavigationOperatorName
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getCompleteOCLNavigationOperatorNameAccess().getAlternatives()); }
(rule__CompleteOCLNavigationOperatorName__Alternatives)
{ after(grammarAccess.getCompleteOCLNavigationOperatorNameAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleClassifierContextDeclCS
entryRuleClassifierContextDeclCS
:
{ before(grammarAccess.getClassifierContextDeclCSRule()); }
ruleClassifierContextDeclCS
{ after(grammarAccess.getClassifierContextDeclCSRule()); }
EOF
;
// Rule ClassifierContextDeclCS
ruleClassifierContextDeclCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getClassifierContextDeclCSAccess().getGroup()); }
(rule__ClassifierContextDeclCS__Group__0)
{ after(grammarAccess.getClassifierContextDeclCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleConstraintCS
entryRuleConstraintCS
:
{ before(grammarAccess.getConstraintCSRule()); }
ruleConstraintCS
{ after(grammarAccess.getConstraintCSRule()); }
EOF
;
// Rule ConstraintCS
ruleConstraintCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getConstraintCSAccess().getGroup()); }
(rule__ConstraintCS__Group__0)
{ after(grammarAccess.getConstraintCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleContextDeclCS
entryRuleContextDeclCS
:
{ before(grammarAccess.getContextDeclCSRule()); }
ruleContextDeclCS
{ after(grammarAccess.getContextDeclCSRule()); }
EOF
;
// Rule ContextDeclCS
ruleContextDeclCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getContextDeclCSAccess().getAlternatives()); }
(rule__ContextDeclCS__Alternatives)
{ after(grammarAccess.getContextDeclCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleDefCS
entryRuleDefCS
:
{ before(grammarAccess.getDefCSRule()); }
ruleDefCS
{ after(grammarAccess.getDefCSRule()); }
EOF
;
// Rule DefCS
ruleDefCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getDefCSAccess().getAlternatives()); }
(rule__DefCS__Alternatives)
{ after(grammarAccess.getDefCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleDefOperationCS
entryRuleDefOperationCS
:
{ before(grammarAccess.getDefOperationCSRule()); }
ruleDefOperationCS
{ after(grammarAccess.getDefOperationCSRule()); }
EOF
;
// Rule DefOperationCS
ruleDefOperationCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getDefOperationCSAccess().getGroup()); }
(rule__DefOperationCS__Group__0)
{ after(grammarAccess.getDefOperationCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleDefParameterCS
entryRuleDefParameterCS
:
{ before(grammarAccess.getDefParameterCSRule()); }
ruleDefParameterCS
{ after(grammarAccess.getDefParameterCSRule()); }
EOF
;
// Rule DefParameterCS
ruleDefParameterCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getDefParameterCSAccess().getGroup()); }
(rule__DefParameterCS__Group__0)
{ after(grammarAccess.getDefParameterCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleDefPropertyCS
entryRuleDefPropertyCS
:
{ before(grammarAccess.getDefPropertyCSRule()); }
ruleDefPropertyCS
{ after(grammarAccess.getDefPropertyCSRule()); }
EOF
;
// Rule DefPropertyCS
ruleDefPropertyCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getDefPropertyCSAccess().getGroup()); }
(rule__DefPropertyCS__Group__0)
{ after(grammarAccess.getDefPropertyCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleImportCS
entryRuleImportCS
:
{ before(grammarAccess.getImportCSRule()); }
ruleImportCS
{ after(grammarAccess.getImportCSRule()); }
EOF
;
// Rule ImportCS
ruleImportCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getImportCSAccess().getGroup()); }
(rule__ImportCS__Group__0)
{ after(grammarAccess.getImportCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleOperationContextDeclCS
entryRuleOperationContextDeclCS
:
{ before(grammarAccess.getOperationContextDeclCSRule()); }
ruleOperationContextDeclCS
{ after(grammarAccess.getOperationContextDeclCSRule()); }
EOF
;
// Rule OperationContextDeclCS
ruleOperationContextDeclCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getOperationContextDeclCSAccess().getGroup()); }
(rule__OperationContextDeclCS__Group__0)
{ after(grammarAccess.getOperationContextDeclCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePackageDeclarationCS
entryRulePackageDeclarationCS
:
{ before(grammarAccess.getPackageDeclarationCSRule()); }
rulePackageDeclarationCS
{ after(grammarAccess.getPackageDeclarationCSRule()); }
EOF
;
// Rule PackageDeclarationCS
rulePackageDeclarationCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPackageDeclarationCSAccess().getGroup()); }
(rule__PackageDeclarationCS__Group__0)
{ after(grammarAccess.getPackageDeclarationCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleParameterCS
entryRuleParameterCS
:
{ before(grammarAccess.getParameterCSRule()); }
ruleParameterCS
{ after(grammarAccess.getParameterCSRule()); }
EOF
;
// Rule ParameterCS
ruleParameterCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getParameterCSAccess().getGroup()); }
(rule__ParameterCS__Group__0)
{ after(grammarAccess.getParameterCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePropertyContextDeclCS
entryRulePropertyContextDeclCS
:
{ before(grammarAccess.getPropertyContextDeclCSRule()); }
rulePropertyContextDeclCS
{ after(grammarAccess.getPropertyContextDeclCSRule()); }
EOF
;
// Rule PropertyContextDeclCS
rulePropertyContextDeclCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPropertyContextDeclCSAccess().getGroup()); }
(rule__PropertyContextDeclCS__Group__0)
{ after(grammarAccess.getPropertyContextDeclCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleSpecificationCS
entryRuleSpecificationCS
:
{ before(grammarAccess.getSpecificationCSRule()); }
ruleSpecificationCS
{ after(grammarAccess.getSpecificationCSRule()); }
EOF
;
// Rule SpecificationCS
ruleSpecificationCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getSpecificationCSAccess().getAlternatives()); }
(rule__SpecificationCS__Alternatives)
{ after(grammarAccess.getSpecificationCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTemplateSignatureCS
entryRuleTemplateSignatureCS
:
{ before(grammarAccess.getTemplateSignatureCSRule()); }
ruleTemplateSignatureCS
{ after(grammarAccess.getTemplateSignatureCSRule()); }
EOF
;
// Rule TemplateSignatureCS
ruleTemplateSignatureCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTemplateSignatureCSAccess().getAlternatives()); }
(rule__TemplateSignatureCS__Alternatives)
{ after(grammarAccess.getTemplateSignatureCSAccess().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().getAlternatives()); }
(rule__TypedRefCS__Alternatives)
{ after(grammarAccess.getTypedRefCSAccess().getAlternatives()); }
)
;
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().getAlternatives()); }
(rule__UnrestrictedName__Alternatives)
{ after(grammarAccess.getUnrestrictedNameAccess().getAlternatives()); }
)
;
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().getAlternatives()); }
(rule__NavigatingArgExpCS__Alternatives)
{ after(grammarAccess.getNavigatingArgExpCSAccess().getAlternatives()); }
)
;
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().getAlternatives()); }
(rule__NavigationOperatorName__Alternatives)
{ after(grammarAccess.getNavigationOperatorNameAccess().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 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 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 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 entryRuleURIPathNameCS
entryRuleURIPathNameCS
:
{ before(grammarAccess.getURIPathNameCSRule()); }
ruleURIPathNameCS
{ after(grammarAccess.getURIPathNameCSRule()); }
EOF
;
// Rule URIPathNameCS
ruleURIPathNameCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getURIPathNameCSAccess().getGroup()); }
(rule__URIPathNameCS__Group__0)
{ after(grammarAccess.getURIPathNameCSAccess().getGroup()); }
)
;
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 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 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 entryRuleUnreservedPathNameCS
entryRuleUnreservedPathNameCS
:
{ before(grammarAccess.getUnreservedPathNameCSRule()); }
ruleUnreservedPathNameCS
{ after(grammarAccess.getUnreservedPathNameCSRule()); }
EOF
;
// Rule UnreservedPathNameCS
ruleUnreservedPathNameCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getUnreservedPathNameCSAccess().getGroup()); }
(rule__UnreservedPathNameCS__Group__0)
{ after(grammarAccess.getUnreservedPathNameCSAccess().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 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__CompleteOCLDocumentCS__Alternatives_1
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getCompleteOCLDocumentCSAccess().getOwnedPackagesAssignment_1_0()); }
(rule__CompleteOCLDocumentCS__OwnedPackagesAssignment_1_0)
{ after(grammarAccess.getCompleteOCLDocumentCSAccess().getOwnedPackagesAssignment_1_0()); }
)
|(
{ before(grammarAccess.getCompleteOCLDocumentCSAccess().getOwnedContextsAssignment_1_1()); }
(rule__CompleteOCLDocumentCS__OwnedContextsAssignment_1_1)
{ after(grammarAccess.getCompleteOCLDocumentCSAccess().getOwnedContextsAssignment_1_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__CompleteOCLNavigationOperatorName__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getCompleteOCLNavigationOperatorNameAccess().getCircumflexAccentKeyword_0()); }
'^'
{ after(grammarAccess.getCompleteOCLNavigationOperatorNameAccess().getCircumflexAccentKeyword_0()); }
)
|(
{ before(grammarAccess.getCompleteOCLNavigationOperatorNameAccess().getCircumflexAccentCircumflexAccentKeyword_1()); }
'^^'
{ after(grammarAccess.getCompleteOCLNavigationOperatorNameAccess().getCircumflexAccentCircumflexAccentKeyword_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__ClassifierContextDeclCS__Alternatives_4
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getClassifierContextDeclCSAccess().getGroup_4_0()); }
(rule__ClassifierContextDeclCS__Group_4_0__0)
{ after(grammarAccess.getClassifierContextDeclCSAccess().getGroup_4_0()); }
)
|(
{ before(grammarAccess.getClassifierContextDeclCSAccess().getOwnedDefinitionsAssignment_4_1()); }
(rule__ClassifierContextDeclCS__OwnedDefinitionsAssignment_4_1)
{ after(grammarAccess.getClassifierContextDeclCSAccess().getOwnedDefinitionsAssignment_4_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__ContextDeclCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getContextDeclCSAccess().getPropertyContextDeclCSParserRuleCall_0()); }
rulePropertyContextDeclCS
{ after(grammarAccess.getContextDeclCSAccess().getPropertyContextDeclCSParserRuleCall_0()); }
)
|(
{ before(grammarAccess.getContextDeclCSAccess().getClassifierContextDeclCSParserRuleCall_1()); }
ruleClassifierContextDeclCS
{ after(grammarAccess.getContextDeclCSAccess().getClassifierContextDeclCSParserRuleCall_1()); }
)
|(
{ before(grammarAccess.getContextDeclCSAccess().getOperationContextDeclCSParserRuleCall_2()); }
ruleOperationContextDeclCS
{ after(grammarAccess.getContextDeclCSAccess().getOperationContextDeclCSParserRuleCall_2()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__DefCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getDefCSAccess().getDefOperationCSParserRuleCall_0()); }
ruleDefOperationCS
{ after(grammarAccess.getDefCSAccess().getDefOperationCSParserRuleCall_0()); }
)
|(
{ before(grammarAccess.getDefCSAccess().getDefPropertyCSParserRuleCall_1()); }
ruleDefPropertyCS
{ after(grammarAccess.getDefCSAccess().getDefPropertyCSParserRuleCall_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__ImportCS__Alternatives_0
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getImportCSAccess().getImportKeyword_0_0()); }
'import'
{ after(grammarAccess.getImportCSAccess().getImportKeyword_0_0()); }
)
|(
{ before(grammarAccess.getImportCSAccess().getIncludeKeyword_0_1()); }
'include'
{ after(grammarAccess.getImportCSAccess().getIncludeKeyword_0_1()); }
)
|(
{ before(grammarAccess.getImportCSAccess().getLibraryKeyword_0_2()); }
'library'
{ after(grammarAccess.getImportCSAccess().getLibraryKeyword_0_2()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__OperationContextDeclCS__Alternatives_8
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getOperationContextDeclCSAccess().getGroup_8_0()); }
(rule__OperationContextDeclCS__Group_8_0__0)
{ after(grammarAccess.getOperationContextDeclCSAccess().getGroup_8_0()); }
)
|(
{ before(grammarAccess.getOperationContextDeclCSAccess().getGroup_8_1()); }
(rule__OperationContextDeclCS__Group_8_1__0)
{ after(grammarAccess.getOperationContextDeclCSAccess().getGroup_8_1()); }
)
|(
{ before(grammarAccess.getOperationContextDeclCSAccess().getGroup_8_2()); }
(rule__OperationContextDeclCS__Group_8_2__0)
{ after(grammarAccess.getOperationContextDeclCSAccess().getGroup_8_2()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__PropertyContextDeclCS__Alternatives_4
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPropertyContextDeclCSAccess().getGroup_4_0()); }
(rule__PropertyContextDeclCS__Group_4_0__0)
{ after(grammarAccess.getPropertyContextDeclCSAccess().getGroup_4_0()); }
)
|(
{ before(grammarAccess.getPropertyContextDeclCSAccess().getGroup_4_1()); }
(rule__PropertyContextDeclCS__Group_4_1__0)
{ after(grammarAccess.getPropertyContextDeclCSAccess().getGroup_4_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__SpecificationCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getSpecificationCSAccess().getOwnedExpressionAssignment_0()); }
(rule__SpecificationCS__OwnedExpressionAssignment_0)
{ after(grammarAccess.getSpecificationCSAccess().getOwnedExpressionAssignment_0()); }
)
|(
{ before(grammarAccess.getSpecificationCSAccess().getExprStringAssignment_1()); }
(rule__SpecificationCS__ExprStringAssignment_1)
{ after(grammarAccess.getSpecificationCSAccess().getExprStringAssignment_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__TemplateSignatureCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTemplateSignatureCSAccess().getGroup_0()); }
(rule__TemplateSignatureCS__Group_0__0)
{ after(grammarAccess.getTemplateSignatureCSAccess().getGroup_0()); }
)
|(
{ before(grammarAccess.getTemplateSignatureCSAccess().getGroup_1()); }
(rule__TemplateSignatureCS__Group_1__0)
{ after(grammarAccess.getTemplateSignatureCSAccess().getGroup_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__TypedRefCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTypedRefCSAccess().getTypeLiteralCSParserRuleCall_0()); }
ruleTypeLiteralCS
{ after(grammarAccess.getTypedRefCSAccess().getTypeLiteralCSParserRuleCall_0()); }
)
|(
{ before(grammarAccess.getTypedRefCSAccess().getTypedTypeRefCSParserRuleCall_1()); }
ruleTypedTypeRefCS
{ after(grammarAccess.getTypedRefCSAccess().getTypedTypeRefCSParserRuleCall_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__UnrestrictedName__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getUnrestrictedNameAccess().getEssentialOCLUnrestrictedNameParserRuleCall_0()); }
ruleEssentialOCLUnrestrictedName
{ after(grammarAccess.getUnrestrictedNameAccess().getEssentialOCLUnrestrictedNameParserRuleCall_0()); }
)
|(
{ before(grammarAccess.getUnrestrictedNameAccess().getImportKeyword_1()); }
'import'
{ after(grammarAccess.getUnrestrictedNameAccess().getImportKeyword_1()); }
)
|(
{ before(grammarAccess.getUnrestrictedNameAccess().getIncludeKeyword_2()); }
'include'
{ after(grammarAccess.getUnrestrictedNameAccess().getIncludeKeyword_2()); }
)
|(
{ before(grammarAccess.getUnrestrictedNameAccess().getLibraryKeyword_3()); }
'library'
{ after(grammarAccess.getUnrestrictedNameAccess().getLibraryKeyword_3()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__NavigatingArgExpCS__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getNavigatingArgExpCSAccess().getGroup_0()); }
(rule__NavigatingArgExpCS__Group_0__0)
{ after(grammarAccess.getNavigatingArgExpCSAccess().getGroup_0()); }
)
|(
{ before(grammarAccess.getNavigatingArgExpCSAccess().getExpCSParserRuleCall_1()); }
ruleExpCS
{ after(grammarAccess.getNavigatingArgExpCSAccess().getExpCSParserRuleCall_1()); }
)
;
finally {
restoreStackSize(stackSize);
}
rule__NavigationOperatorName__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getNavigationOperatorNameAccess().getEssentialOCLNavigationOperatorNameParserRuleCall_0()); }
ruleEssentialOCLNavigationOperatorName
{ after(grammarAccess.getNavigationOperatorNameAccess().getEssentialOCLNavigationOperatorNameParserRuleCall_0()); }
)
|(
{ before(grammarAccess.getNavigationOperatorNameAccess().getCompleteOCLNavigationOperatorNameParserRuleCall_1()); }
ruleCompleteOCLNavigationOperatorName
{ after(grammarAccess.getNavigationOperatorNameAccess().getCompleteOCLNavigationOperatorNameParserRuleCall_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'