| /******************************************************************************* |
| * 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' |
| |
|