blob: 407c3f87bbd3dfd48108d6394f891761f64324e3 [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 InternalOCLinEcore;
options {
superClass=AbstractInternalContentAssistParser;
backtrack=true;
}
@lexer::header {
package org.eclipse.ocl.xtext.oclinecore.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.oclinecore.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.oclinecore.services.OCLinEcoreGrammarAccess;
}
@parser::members {
private OCLinEcoreGrammarAccess grammarAccess;
public void setGrammarAccess(OCLinEcoreGrammarAccess grammarAccess) {
this.grammarAccess = grammarAccess;
}
@Override
protected Grammar getGrammar() {
return grammarAccess.getGrammar();
}
@Override
protected String getValueForTokenName(String tokenName) {
return tokenName;
}
}
// Entry rule entryRuleTopLevelCS
entryRuleTopLevelCS
:
{ before(grammarAccess.getTopLevelCSRule()); }
ruleTopLevelCS
{ after(grammarAccess.getTopLevelCSRule()); }
EOF
;
// Rule TopLevelCS
ruleTopLevelCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTopLevelCSAccess().getGroup()); }
(rule__TopLevelCS__Group__0)
{ after(grammarAccess.getTopLevelCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleSIGNED
entryRuleSIGNED
:
{ before(grammarAccess.getSIGNEDRule()); }
ruleSIGNED
{ after(grammarAccess.getSIGNEDRule()); }
EOF
;
// Rule SIGNED
ruleSIGNED
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getSIGNEDAccess().getGroup()); }
(rule__SIGNED__Group__0)
{ after(grammarAccess.getSIGNEDAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleEnumerationLiteralName
entryRuleEnumerationLiteralName
:
{ before(grammarAccess.getEnumerationLiteralNameRule()); }
ruleEnumerationLiteralName
{ after(grammarAccess.getEnumerationLiteralNameRule()); }
EOF
;
// Rule EnumerationLiteralName
ruleEnumerationLiteralName
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getEnumerationLiteralNameAccess().getAlternatives()); }
(rule__EnumerationLiteralName__Alternatives)
{ after(grammarAccess.getEnumerationLiteralNameAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleInvariantConstraintCS
entryRuleInvariantConstraintCS
:
{ before(grammarAccess.getInvariantConstraintCSRule()); }
ruleInvariantConstraintCS
{ after(grammarAccess.getInvariantConstraintCSRule()); }
EOF
;
// Rule InvariantConstraintCS
ruleInvariantConstraintCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getInvariantConstraintCSAccess().getGroup()); }
(rule__InvariantConstraintCS__Group__0)
{ after(grammarAccess.getInvariantConstraintCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePostconditionConstraintCS
entryRulePostconditionConstraintCS
:
{ before(grammarAccess.getPostconditionConstraintCSRule()); }
rulePostconditionConstraintCS
{ after(grammarAccess.getPostconditionConstraintCSRule()); }
EOF
;
// Rule PostconditionConstraintCS
rulePostconditionConstraintCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPostconditionConstraintCSAccess().getGroup()); }
(rule__PostconditionConstraintCS__Group__0)
{ after(grammarAccess.getPostconditionConstraintCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePreconditionConstraintCS
entryRulePreconditionConstraintCS
:
{ before(grammarAccess.getPreconditionConstraintCSRule()); }
rulePreconditionConstraintCS
{ after(grammarAccess.getPreconditionConstraintCSRule()); }
EOF
;
// Rule PreconditionConstraintCS
rulePreconditionConstraintCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPreconditionConstraintCSAccess().getGroup()); }
(rule__PreconditionConstraintCS__Group__0)
{ after(grammarAccess.getPreconditionConstraintCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleAnnotationCS
entryRuleAnnotationCS
:
{ before(grammarAccess.getAnnotationCSRule()); }
ruleAnnotationCS
{ after(grammarAccess.getAnnotationCSRule()); }
EOF
;
// Rule AnnotationCS
ruleAnnotationCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getAnnotationCSAccess().getGroup()); }
(rule__AnnotationCS__Group__0)
{ after(grammarAccess.getAnnotationCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleAnnotationElementCS
entryRuleAnnotationElementCS
:
{ before(grammarAccess.getAnnotationElementCSRule()); }
ruleAnnotationElementCS
{ after(grammarAccess.getAnnotationElementCSRule()); }
EOF
;
// Rule AnnotationElementCS
ruleAnnotationElementCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getAnnotationElementCSAccess().getAlternatives()); }
(rule__AnnotationElementCS__Alternatives)
{ after(grammarAccess.getAnnotationElementCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleAttributeCS
entryRuleAttributeCS
:
{ before(grammarAccess.getAttributeCSRule()); }
ruleAttributeCS
{ after(grammarAccess.getAttributeCSRule()); }
EOF
;
// Rule AttributeCS
ruleAttributeCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getAttributeCSAccess().getGroup()); }
(rule__AttributeCS__Group__0)
{ after(grammarAccess.getAttributeCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleClassCS
entryRuleClassCS
:
{ before(grammarAccess.getClassCSRule()); }
ruleClassCS
{ after(grammarAccess.getClassCSRule()); }
EOF
;
// Rule ClassCS
ruleClassCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getClassCSAccess().getAlternatives()); }
(rule__ClassCS__Alternatives)
{ after(grammarAccess.getClassCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleDataTypeCS
entryRuleDataTypeCS
:
{ before(grammarAccess.getDataTypeCSRule()); }
ruleDataTypeCS
{ after(grammarAccess.getDataTypeCSRule()); }
EOF
;
// Rule DataTypeCS
ruleDataTypeCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getDataTypeCSAccess().getGroup()); }
(rule__DataTypeCS__Group__0)
{ after(grammarAccess.getDataTypeCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleDetailCS
entryRuleDetailCS
:
{ before(grammarAccess.getDetailCSRule()); }
ruleDetailCS
{ after(grammarAccess.getDetailCSRule()); }
EOF
;
// Rule DetailCS
ruleDetailCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getDetailCSAccess().getGroup()); }
(rule__DetailCS__Group__0)
{ after(grammarAccess.getDetailCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleDocumentationCS
entryRuleDocumentationCS
:
{ before(grammarAccess.getDocumentationCSRule()); }
ruleDocumentationCS
{ after(grammarAccess.getDocumentationCSRule()); }
EOF
;
// Rule DocumentationCS
ruleDocumentationCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getDocumentationCSAccess().getGroup()); }
(rule__DocumentationCS__Group__0)
{ after(grammarAccess.getDocumentationCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleEnumerationCS
entryRuleEnumerationCS
:
{ before(grammarAccess.getEnumerationCSRule()); }
ruleEnumerationCS
{ after(grammarAccess.getEnumerationCSRule()); }
EOF
;
// Rule EnumerationCS
ruleEnumerationCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getEnumerationCSAccess().getGroup()); }
(rule__EnumerationCS__Group__0)
{ after(grammarAccess.getEnumerationCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleEnumerationLiteralCS
entryRuleEnumerationLiteralCS
:
{ before(grammarAccess.getEnumerationLiteralCSRule()); }
ruleEnumerationLiteralCS
{ after(grammarAccess.getEnumerationLiteralCSRule()); }
EOF
;
// Rule EnumerationLiteralCS
ruleEnumerationLiteralCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getEnumerationLiteralCSAccess().getGroup()); }
(rule__EnumerationLiteralCS__Group__0)
{ after(grammarAccess.getEnumerationLiteralCSAccess().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 entryRuleModelElementCS
entryRuleModelElementCS
:
{ before(grammarAccess.getModelElementCSRule()); }
ruleModelElementCS
{ after(grammarAccess.getModelElementCSRule()); }
EOF
;
// Rule ModelElementCS
ruleModelElementCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getModelElementCSAccess().getAlternatives()); }
(rule__ModelElementCS__Alternatives)
{ after(grammarAccess.getModelElementCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleModelElementRefCS
entryRuleModelElementRefCS
:
{ before(grammarAccess.getModelElementRefCSRule()); }
ruleModelElementRefCS
{ after(grammarAccess.getModelElementRefCSRule()); }
EOF
;
// Rule ModelElementRefCS
ruleModelElementRefCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getModelElementRefCSAccess().getGroup()); }
(rule__ModelElementRefCS__Group__0)
{ after(grammarAccess.getModelElementRefCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleOperationCS
entryRuleOperationCS
:
{ before(grammarAccess.getOperationCSRule()); }
ruleOperationCS
{ after(grammarAccess.getOperationCSRule()); }
EOF
;
// Rule OperationCS
ruleOperationCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getOperationCSAccess().getGroup()); }
(rule__OperationCS__Group__0)
{ after(grammarAccess.getOperationCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRulePackageCS
entryRulePackageCS
:
{ before(grammarAccess.getPackageCSRule()); }
rulePackageCS
{ after(grammarAccess.getPackageCSRule()); }
EOF
;
// Rule PackageCS
rulePackageCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getPackageCSAccess().getGroup()); }
(rule__PackageCS__Group__0)
{ after(grammarAccess.getPackageCSAccess().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 entryRuleImplicitOppositeCS
entryRuleImplicitOppositeCS
:
{ before(grammarAccess.getImplicitOppositeCSRule()); }
ruleImplicitOppositeCS
{ after(grammarAccess.getImplicitOppositeCSRule()); }
EOF
;
// Rule ImplicitOppositeCS
ruleImplicitOppositeCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getImplicitOppositeCSAccess().getGroup()); }
(rule__ImplicitOppositeCS__Group__0)
{ after(grammarAccess.getImplicitOppositeCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleReferenceCS
entryRuleReferenceCS
:
{ before(grammarAccess.getReferenceCSRule()); }
ruleReferenceCS
{ after(grammarAccess.getReferenceCSRule()); }
EOF
;
// Rule ReferenceCS
ruleReferenceCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getReferenceCSAccess().getGroup()); }
(rule__ReferenceCS__Group__0)
{ after(grammarAccess.getReferenceCSAccess().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 entryRuleStructuredClassCS
entryRuleStructuredClassCS
:
{ before(grammarAccess.getStructuredClassCSRule()); }
ruleStructuredClassCS
{ after(grammarAccess.getStructuredClassCSRule()); }
EOF
;
// Rule StructuredClassCS
ruleStructuredClassCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getStructuredClassCSAccess().getGroup()); }
(rule__StructuredClassCS__Group__0)
{ after(grammarAccess.getStructuredClassCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleStructuralFeatureCS
entryRuleStructuralFeatureCS
:
{ before(grammarAccess.getStructuralFeatureCSRule()); }
ruleStructuralFeatureCS
{ after(grammarAccess.getStructuralFeatureCSRule()); }
EOF
;
// Rule StructuralFeatureCS
ruleStructuralFeatureCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getStructuralFeatureCSAccess().getAlternatives()); }
(rule__StructuralFeatureCS__Alternatives)
{ after(grammarAccess.getStructuralFeatureCSAccess().getAlternatives()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleSysMLCS
entryRuleSysMLCS
:
{ before(grammarAccess.getSysMLCSRule()); }
ruleSysMLCS
{ after(grammarAccess.getSysMLCSRule()); }
EOF
;
// Rule SysMLCS
ruleSysMLCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getSysMLCSAccess().getGroup()); }
(rule__SysMLCS__Group__0)
{ after(grammarAccess.getSysMLCSAccess().getGroup()); }
)
;
finally {
restoreStackSize(stackSize);
}
// Entry rule entryRuleTypedMultiplicityRefCS
entryRuleTypedMultiplicityRefCS
:
{ before(grammarAccess.getTypedMultiplicityRefCSRule()); }
ruleTypedMultiplicityRefCS
{ after(grammarAccess.getTypedMultiplicityRefCSRule()); }
EOF
;
// Rule TypedMultiplicityRefCS
ruleTypedMultiplicityRefCS
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getTypedMultiplicityRefCSAccess().getGroup()); }
(rule__TypedMultiplicityRefCS__Group__0)
{ after(grammarAccess.getTypedMultiplicityRefCSAccess().getGroup()); }
)
;
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 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 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 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 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 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 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__EnumerationLiteralName__Alternatives
@init {
int stackSize = keepStackSize();
}
:
(
{ before(grammarAccess.getEnumerationLiteralNameAccess().getEssentialOCLUnrestrictedNameParserRuleCall_0()); }
ruleEssentialOCLUnrestrictedName
{ after(grammarAccess.getEnumerationLiteralNameAccess().getEssentialOCLUnrestrictedNameParserRuleCall_0()); }
)
|(
{ before(grammarAccess.getEnumerationLiteralNameAccess().getAbstractKeyword_1()); }
'abstract'
{ after(grammarAccess.getEnumerationLiteralNameAccess().getAbstractKeyword_1()); }
)
|(
{ before(grammarAccess.getEnumerationLiteralNameAccess().getAttributeKeyword_2()); }
'attribute'
{ after(grammarAccess.getEnumerationLiteralNameAccess().getAttributeKeyword_2()); }
)
|(
{ before(grammarAccess.getEnumerationLiteralNameAccess().getBodyKeyword_3()); }
'body'
{ after(grammarAccess.getEnumerationLiteralNameAccess().getBodyKeyword_3()); }
)
|(
{ before(grammarAccess.getEnumerationLiteralNameAccess().getCallableKeyword_4()); }
'callable'
{ after(grammarAccess.getEnumerationLiteralNameAccess().getCallableKeyword_4()); }
)
|(
{ before(grammarAccess.getEnumerationLiteralNameAccess().getClassKeyword_5()); }
'class'
{ after(grammarAccess.getEnumerationLiteralNameAccess().getClassKeyword_5()); }
)
|(
{ before(grammarAccess.getEnumerationLiteralNameAccess().getComposesKeyword_6()); }
'composes'
{ after(grammarAccess.getEnumerationLiteralNameAccess().getComposesKeyword_6()); }
)
|(
{ before(grammarAccess.getEnumerationLiteralNameAccess().getDatatypeKeyword_7()); }
'datatype'
{ after(grammarAccess.getEnumerationLiteralNameAccess().getDatatypeKeyword_7()); }
)
|(
{ before(grammarAccess.getEnumerationLiteralNameAccess().getDefinitionKeyword_8()); }
'definition'
{ after(grammarAccess.getEnumerationLiteralNameAccess().getDefinitionKeyword_8()); }
)
|(
{ before(grammarAccess.getEnumerationLiteralNameAccess().getDerivationKeyword_9()); }
'derivation'
{ after(grammarAccess.getEnumerationLiteralNameAccess().getDerivationKeyword_9()); }
)
|(
{ before(grammarAccess.getEnumerationLiteralNameAccess().getDerivedKeyword_10()); }
'derived'
{ after(grammarAccess.getEnumerationLiteralNameAccess().getDerivedKeyword_10()); }
)
|(
{ before(grammarAccess.getEnumerationLiteralNameAccess().getEnumKeyword_11()); }
'enum'