Skip to main content
aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to 'sandbox/Alf/org.eclipse.papyrus.alf/src-gen/org/eclipse/papyrus/alf/parser/antlr/internal/InternalAlf.g')
-rw-r--r--sandbox/Alf/org.eclipse.papyrus.alf/src-gen/org/eclipse/papyrus/alf/parser/antlr/internal/InternalAlf.g13964
1 files changed, 13964 insertions, 0 deletions
diff --git a/sandbox/Alf/org.eclipse.papyrus.alf/src-gen/org/eclipse/papyrus/alf/parser/antlr/internal/InternalAlf.g b/sandbox/Alf/org.eclipse.papyrus.alf/src-gen/org/eclipse/papyrus/alf/parser/antlr/internal/InternalAlf.g
new file mode 100644
index 00000000000..0916e50ec04
--- /dev/null
+++ b/sandbox/Alf/org.eclipse.papyrus.alf/src-gen/org/eclipse/papyrus/alf/parser/antlr/internal/InternalAlf.g
@@ -0,0 +1,13964 @@
+/*
+* generated by Xtext
+*/
+grammar InternalAlf;
+
+options {
+ superClass=AbstractInternalAntlrParser;
+
+}
+
+@lexer::header {
+package org.eclipse.papyrus.alf.parser.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.parser.antlr.Lexer;
+}
+
+@parser::header {
+package org.eclipse.papyrus.alf.parser.antlr.internal;
+
+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.emf.common.util.Enumerator;
+import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
+import org.eclipse.papyrus.alf.services.AlfGrammarAccess;
+
+}
+
+@parser::members {
+
+ private AlfGrammarAccess grammarAccess;
+
+ public InternalAlfParser(TokenStream input, AlfGrammarAccess grammarAccess) {
+ this(input);
+ this.grammarAccess = grammarAccess;
+ registerRules(grammarAccess.getGrammar());
+ }
+
+ @Override
+ protected String getFirstRuleName() {
+ return "UnitDefinition";
+ }
+
+ @Override
+ protected AlfGrammarAccess getGrammarAccess() {
+ return grammarAccess;
+ }
+}
+
+@rulecatch {
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+}
+
+
+
+
+// Entry rule entryRuleUnitDefinition
+entryRuleUnitDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getUnitDefinitionRule()); }
+ iv_ruleUnitDefinition=ruleUnitDefinition
+ { $current=$iv_ruleUnitDefinition.current; }
+ EOF
+;
+
+// Rule UnitDefinition
+ruleUnitDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getUnitDefinitionAccess().getNamespaceDeclarationNamespaceDeclarationParserRuleCall_0_0());
+ }
+ lv_namespaceDeclaration_0_0=ruleNamespaceDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getUnitDefinitionRule());
+ }
+ set(
+ $current,
+ "namespaceDeclaration",
+ lv_namespaceDeclaration_0_0,
+ "NamespaceDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getUnitDefinitionAccess().getImportDeclarationsImportDeclarationParserRuleCall_1_0());
+ }
+ lv_importDeclarations_1_0=ruleImportDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getUnitDefinitionRule());
+ }
+ add(
+ $current,
+ "importDeclarations",
+ lv_importDeclarations_1_0,
+ "ImportDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)*(
+(
+ lv_comment_2_0=RULE_ML_COMMENT
+ {
+ newLeafNode(lv_comment_2_0, grammarAccess.getUnitDefinitionAccess().getCommentML_COMMENTTerminalRuleCall_2_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getUnitDefinitionRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "comment",
+ lv_comment_2_0,
+ "ML_COMMENT");
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getUnitDefinitionAccess().getStereotypeAnnotationsStereotypeAnnotationsParserRuleCall_3_0());
+ }
+ lv_stereotypeAnnotations_3_0=ruleStereotypeAnnotations {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getUnitDefinitionRule());
+ }
+ set(
+ $current,
+ "stereotypeAnnotations",
+ lv_stereotypeAnnotations_3_0,
+ "StereotypeAnnotations");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getUnitDefinitionAccess().getNamesapceDefinitionNamespaceDefinitionParserRuleCall_4_0());
+ }
+ lv_namesapceDefinition_4_0=ruleNamespaceDefinition {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getUnitDefinitionRule());
+ }
+ set(
+ $current,
+ "namesapceDefinition",
+ lv_namesapceDefinition_4_0,
+ "NamespaceDefinition");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleBOOLEAN_LITERAL
+entryRuleBOOLEAN_LITERAL returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getBOOLEAN_LITERALRule()); }
+ iv_ruleBOOLEAN_LITERAL=ruleBOOLEAN_LITERAL
+ { $current=$iv_ruleBOOLEAN_LITERAL.current; }
+ EOF
+;
+
+// Rule BOOLEAN_LITERAL
+ruleBOOLEAN_LITERAL returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ lv_value_0_0=RULE_BOOLEAN_VALUE
+ {
+ newLeafNode(lv_value_0_0, grammarAccess.getBOOLEAN_LITERALAccess().getValueBOOLEAN_VALUETerminalRuleCall_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getBOOLEAN_LITERALRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "value",
+ lv_value_0_0,
+ "BOOLEAN_VALUE");
+ }
+
+)
+)
+;
+
+
+
+
+
+// Entry rule entryRuleNUMBER_LITERAL
+entryRuleNUMBER_LITERAL returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNUMBER_LITERALRule()); }
+ iv_ruleNUMBER_LITERAL=ruleNUMBER_LITERAL
+ { $current=$iv_ruleNUMBER_LITERAL.current; }
+ EOF
+;
+
+// Rule NUMBER_LITERAL
+ruleNUMBER_LITERAL returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getNUMBER_LITERALAccess().getINTEGER_LITERALParserRuleCall_0());
+ }
+ this_INTEGER_LITERAL_0=ruleINTEGER_LITERAL
+ {
+ $current = $this_INTEGER_LITERAL_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getNUMBER_LITERALAccess().getUNLIMITED_NATURALParserRuleCall_1());
+ }
+ this_UNLIMITED_NATURAL_1=ruleUNLIMITED_NATURAL
+ {
+ $current = $this_UNLIMITED_NATURAL_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleINTEGER_LITERAL
+entryRuleINTEGER_LITERAL returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getINTEGER_LITERALRule()); }
+ iv_ruleINTEGER_LITERAL=ruleINTEGER_LITERAL
+ { $current=$iv_ruleINTEGER_LITERAL.current; }
+ EOF
+;
+
+// Rule INTEGER_LITERAL
+ruleINTEGER_LITERAL returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ lv_value_0_0=RULE_INTEGER_VALUE
+ {
+ newLeafNode(lv_value_0_0, grammarAccess.getINTEGER_LITERALAccess().getValueINTEGER_VALUETerminalRuleCall_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getINTEGER_LITERALRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "value",
+ lv_value_0_0,
+ "INTEGER_VALUE");
+ }
+
+)
+)
+;
+
+
+
+
+
+// Entry rule entryRuleUNLIMITED_NATURAL
+entryRuleUNLIMITED_NATURAL returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getUNLIMITED_NATURALRule()); }
+ iv_ruleUNLIMITED_NATURAL=ruleUNLIMITED_NATURAL
+ { $current=$iv_ruleUNLIMITED_NATURAL.current; }
+ EOF
+;
+
+// Rule UNLIMITED_NATURAL
+ruleUNLIMITED_NATURAL returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ lv_value_0_0= '*'
+ {
+ newLeafNode(lv_value_0_0, grammarAccess.getUNLIMITED_NATURALAccess().getValueAsteriskKeyword_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getUNLIMITED_NATURALRule());
+ }
+ setWithLastConsumed($current, "value", lv_value_0_0, "*");
+ }
+
+)
+)
+;
+
+
+
+
+
+// Entry rule entryRuleSTRING_LITERAL
+entryRuleSTRING_LITERAL returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSTRING_LITERALRule()); }
+ iv_ruleSTRING_LITERAL=ruleSTRING_LITERAL
+ { $current=$iv_ruleSTRING_LITERAL.current; }
+ EOF
+;
+
+// Rule STRING_LITERAL
+ruleSTRING_LITERAL returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ lv_value_0_0=RULE_STRING
+ {
+ newLeafNode(lv_value_0_0, grammarAccess.getSTRING_LITERALAccess().getValueSTRINGTerminalRuleCall_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getSTRING_LITERALRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "value",
+ lv_value_0_0,
+ "STRING");
+ }
+
+)
+)
+;
+
+
+
+
+
+// Entry rule entryRuleStereotypeAnnotations
+entryRuleStereotypeAnnotations returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getStereotypeAnnotationsRule()); }
+ iv_ruleStereotypeAnnotations=ruleStereotypeAnnotations
+ { $current=$iv_ruleStereotypeAnnotations.current; }
+ EOF
+;
+
+// Rule StereotypeAnnotations
+ruleStereotypeAnnotations returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getStereotypeAnnotationsAccess().getStereotypeAnnotationsAction_0(),
+ $current);
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getStereotypeAnnotationsAccess().getAnnotationStereotypeAnnotationParserRuleCall_1_0());
+ }
+ lv_annotation_1_0=ruleStereotypeAnnotation {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getStereotypeAnnotationsRule());
+ }
+ add(
+ $current,
+ "annotation",
+ lv_annotation_1_0,
+ "StereotypeAnnotation");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)*)
+;
+
+
+
+
+
+// Entry rule entryRuleStereotypeAnnotation
+entryRuleStereotypeAnnotation returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getStereotypeAnnotationRule()); }
+ iv_ruleStereotypeAnnotation=ruleStereotypeAnnotation
+ { $current=$iv_ruleStereotypeAnnotation.current; }
+ EOF
+;
+
+// Rule StereotypeAnnotation
+ruleStereotypeAnnotation returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='@'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getStereotypeAnnotationAccess().getCommercialAtKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getStereotypeAnnotationAccess().getStereotypeNameQualifiedNameParserRuleCall_1_0());
+ }
+ lv_stereotypeName_1_0=ruleQualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getStereotypeAnnotationRule());
+ }
+ set(
+ $current,
+ "stereotypeName",
+ lv_stereotypeName_1_0,
+ "QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_2='('
+ {
+ newLeafNode(otherlv_2, grammarAccess.getStereotypeAnnotationAccess().getLeftParenthesisKeyword_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getStereotypeAnnotationAccess().getTaggedValuesTaggedValuesParserRuleCall_2_1_0());
+ }
+ lv_taggedValues_3_0=ruleTaggedValues {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getStereotypeAnnotationRule());
+ }
+ set(
+ $current,
+ "taggedValues",
+ lv_taggedValues_3_0,
+ "TaggedValues");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_4=')'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getStereotypeAnnotationAccess().getRightParenthesisKeyword_2_2());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleTaggedValues
+entryRuleTaggedValues returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTaggedValuesRule()); }
+ iv_ruleTaggedValues=ruleTaggedValues
+ { $current=$iv_ruleTaggedValues.current; }
+ EOF
+;
+
+// Rule TaggedValues
+ruleTaggedValues returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getTaggedValuesAccess().getQualifiedNameListParserRuleCall_0());
+ }
+ this_QualifiedNameList_0=ruleQualifiedNameList
+ {
+ $current = $this_QualifiedNameList_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTaggedValuesAccess().getTaggedValueListParserRuleCall_1());
+ }
+ this_TaggedValueList_1=ruleTaggedValueList
+ {
+ $current = $this_TaggedValueList_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleTaggedValueList
+entryRuleTaggedValueList returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTaggedValueListRule()); }
+ iv_ruleTaggedValueList=ruleTaggedValueList
+ { $current=$iv_ruleTaggedValueList.current; }
+ EOF
+;
+
+// Rule TaggedValueList
+ruleTaggedValueList returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getTaggedValueListAccess().getTaggedValueTaggedValueParserRuleCall_0_0());
+ }
+ lv_taggedValue_0_0=ruleTaggedValue {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTaggedValueListRule());
+ }
+ add(
+ $current,
+ "taggedValue",
+ lv_taggedValue_0_0,
+ "TaggedValue");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=','
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTaggedValueListAccess().getCommaKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTaggedValueListAccess().getTaggedValueTaggedValueParserRuleCall_1_1_0());
+ }
+ lv_taggedValue_2_0=ruleTaggedValue {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTaggedValueListRule());
+ }
+ add(
+ $current,
+ "taggedValue",
+ lv_taggedValue_2_0,
+ "TaggedValue");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRulePRIMITIVE_LITERAL
+entryRulePRIMITIVE_LITERAL returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPRIMITIVE_LITERALRule()); }
+ iv_rulePRIMITIVE_LITERAL=rulePRIMITIVE_LITERAL
+ { $current=$iv_rulePRIMITIVE_LITERAL.current; }
+ EOF
+;
+
+// Rule PRIMITIVE_LITERAL
+rulePRIMITIVE_LITERAL returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getPRIMITIVE_LITERALAccess().getBOOLEAN_LITERALParserRuleCall_0());
+ }
+ this_BOOLEAN_LITERAL_0=ruleBOOLEAN_LITERAL
+ {
+ $current = $this_BOOLEAN_LITERAL_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPRIMITIVE_LITERALAccess().getNUMBER_LITERALParserRuleCall_1());
+ }
+ this_NUMBER_LITERAL_1=ruleNUMBER_LITERAL
+ {
+ $current = $this_NUMBER_LITERAL_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPRIMITIVE_LITERALAccess().getSTRING_LITERALParserRuleCall_2());
+ }
+ this_STRING_LITERAL_2=ruleSTRING_LITERAL
+ {
+ $current = $this_STRING_LITERAL_2.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleTaggedValue
+entryRuleTaggedValue returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTaggedValueRule()); }
+ iv_ruleTaggedValue=ruleTaggedValue
+ { $current=$iv_ruleTaggedValue.current; }
+ EOF
+;
+
+// Rule TaggedValue
+ruleTaggedValue returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getTaggedValueAccess().getNameNameParserRuleCall_0_0());
+ }
+ lv_name_0_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTaggedValueRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_0_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_1='=>'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTaggedValueAccess().getEqualsSignGreaterThanSignKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTaggedValueAccess().getValuePRIMITIVE_LITERALParserRuleCall_2_0());
+ }
+ lv_value_2_0=rulePRIMITIVE_LITERAL {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTaggedValueRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_2_0,
+ "PRIMITIVE_LITERAL");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleNamespaceDeclaration
+entryRuleNamespaceDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNamespaceDeclarationRule()); }
+ iv_ruleNamespaceDeclaration=ruleNamespaceDeclaration
+ { $current=$iv_ruleNamespaceDeclaration.current; }
+ EOF
+;
+
+// Rule NamespaceDeclaration
+ruleNamespaceDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='namespace'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getNamespaceDeclarationAccess().getNamespaceKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getNamespaceDeclarationAccess().getQualifiedNameQualifiedNameParserRuleCall_1_0());
+ }
+ lv_qualifiedName_1_0=ruleQualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNamespaceDeclarationRule());
+ }
+ set(
+ $current,
+ "qualifiedName",
+ lv_qualifiedName_1_0,
+ "QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_2=';'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getNamespaceDeclarationAccess().getSemicolonKeyword_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleImportDeclaration
+entryRuleImportDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getImportDeclarationRule()); }
+ iv_ruleImportDeclaration=ruleImportDeclaration
+ { $current=$iv_ruleImportDeclaration.current; }
+ EOF
+;
+
+// Rule ImportDeclaration
+ruleImportDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getImportDeclarationAccess().getVisibilityImportVisibilityIndicatorEnumRuleCall_0_0());
+ }
+ lv_visibility_0_0=ruleImportVisibilityIndicator {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getImportDeclarationRule());
+ }
+ set(
+ $current,
+ "visibility",
+ lv_visibility_0_0,
+ "ImportVisibilityIndicator");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_1='import'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getImportDeclarationAccess().getImportKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getImportDeclarationAccess().getImportReferenceImportReferenceParserRuleCall_2_0());
+ }
+ lv_importReference_2_0=ruleImportReference {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getImportDeclarationRule());
+ }
+ set(
+ $current,
+ "importReference",
+ lv_importReference_2_0,
+ "ImportReference");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_3=';'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getImportDeclarationAccess().getSemicolonKeyword_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleImportReference
+entryRuleImportReference returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getImportReferenceRule()); }
+ iv_ruleImportReference=ruleImportReference
+ { $current=$iv_ruleImportReference.current; }
+ EOF
+;
+
+// Rule ImportReference
+ruleImportReference returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getImportReferenceAccess().getNameNameParserRuleCall_0_0());
+ }
+ lv_name_0_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getImportReferenceRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_0_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((
+(
+ {
+ newCompositeNode(grammarAccess.getImportReferenceAccess().getCompletionImportReferenceQualifiedNameCompletionParserRuleCall_1_0_0());
+ }
+ lv_completion_1_0=ruleImportReferenceQualifiedNameCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getImportReferenceRule());
+ }
+ set(
+ $current,
+ "completion",
+ lv_completion_1_0,
+ "ImportReferenceQualifiedNameCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getImportReferenceAccess().getAliasAliasDefinitionParserRuleCall_1_1_0());
+ }
+ lv_alias_2_0=ruleAliasDefinition {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getImportReferenceRule());
+ }
+ set(
+ $current,
+ "alias",
+ lv_alias_2_0,
+ "AliasDefinition");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |( otherlv_3='::'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getImportReferenceAccess().getColonColonKeyword_1_2_0());
+ }
+(
+(
+ lv_star_4_0= '*'
+ {
+ newLeafNode(lv_star_4_0, grammarAccess.getImportReferenceAccess().getStarAsteriskKeyword_1_2_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getImportReferenceRule());
+ }
+ setWithLastConsumed($current, "star", true, "*");
+ }
+
+)
+)))?)
+;
+
+
+
+
+
+// Entry rule entryRuleImportReferenceQualifiedNameCompletion
+entryRuleImportReferenceQualifiedNameCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getImportReferenceQualifiedNameCompletionRule()); }
+ iv_ruleImportReferenceQualifiedNameCompletion=ruleImportReferenceQualifiedNameCompletion
+ { $current=$iv_ruleImportReferenceQualifiedNameCompletion.current; }
+ EOF
+;
+
+// Rule ImportReferenceQualifiedNameCompletion
+ruleImportReferenceQualifiedNameCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+
+ {
+ newCompositeNode(grammarAccess.getImportReferenceQualifiedNameCompletionAccess().getColonQualifiedNameCompletionOfImportReferenceParserRuleCall());
+ }
+ this_ColonQualifiedNameCompletionOfImportReference_0=ruleColonQualifiedNameCompletionOfImportReference
+ {
+ $current = $this_ColonQualifiedNameCompletionOfImportReference_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+;
+
+
+
+
+
+// Entry rule entryRuleColonQualifiedNameCompletionOfImportReference
+entryRuleColonQualifiedNameCompletionOfImportReference returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getColonQualifiedNameCompletionOfImportReferenceRule()); }
+ iv_ruleColonQualifiedNameCompletionOfImportReference=ruleColonQualifiedNameCompletionOfImportReference
+ { $current=$iv_ruleColonQualifiedNameCompletionOfImportReference.current; }
+ EOF
+;
+
+// Rule ColonQualifiedNameCompletionOfImportReference
+ruleColonQualifiedNameCompletionOfImportReference returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='::'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getColonQualifiedNameCompletionOfImportReferenceAccess().getColonColonKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getColonQualifiedNameCompletionOfImportReferenceAccess().getNameNameParserRuleCall_1_0());
+ }
+ lv_name_1_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getColonQualifiedNameCompletionOfImportReferenceRule());
+ }
+ add(
+ $current,
+ "name",
+ lv_name_1_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_2='::'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getColonQualifiedNameCompletionOfImportReferenceAccess().getColonColonKeyword_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getColonQualifiedNameCompletionOfImportReferenceAccess().getNameNameParserRuleCall_2_1_0());
+ }
+ lv_name_3_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getColonQualifiedNameCompletionOfImportReferenceRule());
+ }
+ add(
+ $current,
+ "name",
+ lv_name_3_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*(( otherlv_4='::'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getColonQualifiedNameCompletionOfImportReferenceAccess().getColonColonKeyword_3_0_0());
+ }
+(
+(
+ lv_star_5_0= '*'
+ {
+ newLeafNode(lv_star_5_0, grammarAccess.getColonQualifiedNameCompletionOfImportReferenceAccess().getStarAsteriskKeyword_3_0_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getColonQualifiedNameCompletionOfImportReferenceRule());
+ }
+ setWithLastConsumed($current, "star", true, "*");
+ }
+
+)
+))
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getColonQualifiedNameCompletionOfImportReferenceAccess().getAliasAliasDefinitionParserRuleCall_3_1_0());
+ }
+ lv_alias_6_0=ruleAliasDefinition {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getColonQualifiedNameCompletionOfImportReferenceRule());
+ }
+ set(
+ $current,
+ "alias",
+ lv_alias_6_0,
+ "AliasDefinition");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleAliasDefinition
+entryRuleAliasDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAliasDefinitionRule()); }
+ iv_ruleAliasDefinition=ruleAliasDefinition
+ { $current=$iv_ruleAliasDefinition.current; }
+ EOF
+;
+
+// Rule AliasDefinition
+ruleAliasDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='as'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getAliasDefinitionAccess().getAsKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getAliasDefinitionAccess().getAliasNameParserRuleCall_1_0());
+ }
+ lv_alias_1_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAliasDefinitionRule());
+ }
+ set(
+ $current,
+ "alias",
+ lv_alias_1_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleNamespaceDefinition
+entryRuleNamespaceDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNamespaceDefinitionRule()); }
+ iv_ruleNamespaceDefinition=ruleNamespaceDefinition
+ { $current=$iv_ruleNamespaceDefinition.current; }
+ EOF
+;
+
+// Rule NamespaceDefinition
+ruleNamespaceDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getNamespaceDefinitionAccess().getPackageDefinitionParserRuleCall_0());
+ }
+ this_PackageDefinition_0=rulePackageDefinition
+ {
+ $current = $this_PackageDefinition_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getNamespaceDefinitionAccess().getClassifierDefinitionParserRuleCall_1());
+ }
+ this_ClassifierDefinition_1=ruleClassifierDefinition
+ {
+ $current = $this_ClassifierDefinition_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleVisibilityIndicator
+entryRuleVisibilityIndicator returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getVisibilityIndicatorRule()); }
+ iv_ruleVisibilityIndicator=ruleVisibilityIndicator
+ { $current=$iv_ruleVisibilityIndicator.current; }
+ EOF
+;
+
+// Rule VisibilityIndicator
+ruleVisibilityIndicator returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_PUBLIC_0_0= 'public'
+ {
+ newLeafNode(lv_PUBLIC_0_0, grammarAccess.getVisibilityIndicatorAccess().getPUBLICPublicKeyword_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getVisibilityIndicatorRule());
+ }
+ setWithLastConsumed($current, "PUBLIC", lv_PUBLIC_0_0, "public");
+ }
+
+)
+)
+ |(
+(
+ lv_PRIVATE_1_0= 'private'
+ {
+ newLeafNode(lv_PRIVATE_1_0, grammarAccess.getVisibilityIndicatorAccess().getPRIVATEPrivateKeyword_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getVisibilityIndicatorRule());
+ }
+ setWithLastConsumed($current, "PRIVATE", lv_PRIVATE_1_0, "private");
+ }
+
+)
+)
+ |(
+(
+ lv_PROTECTED_2_0= 'protected'
+ {
+ newLeafNode(lv_PROTECTED_2_0, grammarAccess.getVisibilityIndicatorAccess().getPROTECTEDProtectedKeyword_2_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getVisibilityIndicatorRule());
+ }
+ setWithLastConsumed($current, "PROTECTED", lv_PROTECTED_2_0, "protected");
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRulePackageDeclaration
+entryRulePackageDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPackageDeclarationRule()); }
+ iv_rulePackageDeclaration=rulePackageDeclaration
+ { $current=$iv_rulePackageDeclaration.current; }
+ EOF
+;
+
+// Rule PackageDeclaration
+rulePackageDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='package'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getPackageDeclarationAccess().getPackageKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPackageDeclarationAccess().getNameNameParserRuleCall_1_0());
+ }
+ lv_name_1_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPackageDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_1_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRulePackageDefinition
+entryRulePackageDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPackageDefinitionRule()); }
+ iv_rulePackageDefinition=rulePackageDefinition
+ { $current=$iv_rulePackageDefinition.current; }
+ EOF
+;
+
+// Rule PackageDefinition
+rulePackageDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getPackageDefinitionAccess().getDeclarationPackageDeclarationParserRuleCall_0_0());
+ }
+ lv_declaration_0_0=rulePackageDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPackageDefinitionRule());
+ }
+ set(
+ $current,
+ "declaration",
+ lv_declaration_0_0,
+ "PackageDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPackageDefinitionAccess().getBodyPackageBodyParserRuleCall_1_0());
+ }
+ lv_body_1_0=rulePackageBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPackageDefinitionRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_1_0,
+ "PackageBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRulePackageDefinitionOrStub
+entryRulePackageDefinitionOrStub returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPackageDefinitionOrStubRule()); }
+ iv_rulePackageDefinitionOrStub=rulePackageDefinitionOrStub
+ { $current=$iv_rulePackageDefinitionOrStub.current; }
+ EOF
+;
+
+// Rule PackageDefinitionOrStub
+rulePackageDefinitionOrStub returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getPackageDefinitionOrStubAccess().getDeclarationPackageDeclarationParserRuleCall_0_0());
+ }
+ lv_declaration_0_0=rulePackageDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPackageDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "declaration",
+ lv_declaration_0_0,
+ "PackageDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=';'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPackageDefinitionOrStubAccess().getSemicolonKeyword_1_0());
+ }
+
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getPackageDefinitionOrStubAccess().getBodyPackageBodyParserRuleCall_1_1_0());
+ }
+ lv_body_2_0=rulePackageBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPackageDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_2_0,
+ "PackageBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+;
+
+
+
+
+
+// Entry rule entryRulePackageBody
+entryRulePackageBody returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPackageBodyRule()); }
+ iv_rulePackageBody=rulePackageBody
+ { $current=$iv_rulePackageBody.current; }
+ EOF
+;
+
+// Rule PackageBody
+rulePackageBody returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPackageBodyAccess().getPackageBodyAction_0(),
+ $current);
+ }
+) otherlv_1='{'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPackageBodyAccess().getLeftCurlyBracketKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPackageBodyAccess().getPackagedElementPackagedElementParserRuleCall_2_0());
+ }
+ lv_packagedElement_2_0=rulePackagedElement {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPackageBodyRule());
+ }
+ add(
+ $current,
+ "packagedElement",
+ lv_packagedElement_2_0,
+ "PackagedElement");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)* otherlv_3='}'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getPackageBodyAccess().getRightCurlyBracketKeyword_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRulePackagedElement
+entryRulePackagedElement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPackagedElementRule()); }
+ iv_rulePackagedElement=rulePackagedElement
+ { $current=$iv_rulePackagedElement.current; }
+ EOF
+;
+
+// Rule PackagedElement
+rulePackagedElement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_comment_0_0=RULE_ML_COMMENT
+ {
+ newLeafNode(lv_comment_0_0, grammarAccess.getPackagedElementAccess().getCommentML_COMMENTTerminalRuleCall_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getPackagedElementRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "comment",
+ lv_comment_0_0,
+ "ML_COMMENT");
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getPackagedElementAccess().getStereotypeAnnotationsStereotypeAnnotationsParserRuleCall_1_0());
+ }
+ lv_stereotypeAnnotations_1_0=ruleStereotypeAnnotations {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPackagedElementRule());
+ }
+ set(
+ $current,
+ "stereotypeAnnotations",
+ lv_stereotypeAnnotations_1_0,
+ "StereotypeAnnotations");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPackagedElementAccess().getImportVisibilityIndicatorImportVisibilityIndicatorEnumRuleCall_2_0());
+ }
+ lv_importVisibilityIndicator_2_0=ruleImportVisibilityIndicator {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPackagedElementRule());
+ }
+ set(
+ $current,
+ "importVisibilityIndicator",
+ lv_importVisibilityIndicator_2_0,
+ "ImportVisibilityIndicator");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPackagedElementAccess().getPackagedElementDefinitionPackagedElementDefinitionParserRuleCall_3_0());
+ }
+ lv_packagedElementDefinition_3_0=rulePackagedElementDefinition {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPackagedElementRule());
+ }
+ set(
+ $current,
+ "packagedElementDefinition",
+ lv_packagedElementDefinition_3_0,
+ "PackagedElementDefinition");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRulePackagedElementDefinition
+entryRulePackagedElementDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPackagedElementDefinitionRule()); }
+ iv_rulePackagedElementDefinition=rulePackagedElementDefinition
+ { $current=$iv_rulePackagedElementDefinition.current; }
+ EOF
+;
+
+// Rule PackagedElementDefinition
+rulePackagedElementDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getPackagedElementDefinitionAccess().getPackageDefinitionOrStubParserRuleCall_0());
+ }
+ this_PackageDefinitionOrStub_0=rulePackageDefinitionOrStub
+ {
+ $current = $this_PackageDefinitionOrStub_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPackagedElementDefinitionAccess().getClassifierDefinitionOrStubParserRuleCall_1());
+ }
+ this_ClassifierDefinitionOrStub_1=ruleClassifierDefinitionOrStub
+ {
+ $current = $this_ClassifierDefinitionOrStub_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleClassifierDefinition
+entryRuleClassifierDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassifierDefinitionRule()); }
+ iv_ruleClassifierDefinition=ruleClassifierDefinition
+ { $current=$iv_ruleClassifierDefinition.current; }
+ EOF
+;
+
+// Rule ClassifierDefinition
+ruleClassifierDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getClassifierDefinitionAccess().getClassDefinitionParserRuleCall_0());
+ }
+ this_ClassDefinition_0=ruleClassDefinition
+ {
+ $current = $this_ClassDefinition_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getClassifierDefinitionAccess().getActiveClassDefinitionParserRuleCall_1());
+ }
+ this_ActiveClassDefinition_1=ruleActiveClassDefinition
+ {
+ $current = $this_ActiveClassDefinition_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getClassifierDefinitionAccess().getDataTypeDefinitionParserRuleCall_2());
+ }
+ this_DataTypeDefinition_2=ruleDataTypeDefinition
+ {
+ $current = $this_DataTypeDefinition_2.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getClassifierDefinitionAccess().getEnumerationDefinitionParserRuleCall_3());
+ }
+ this_EnumerationDefinition_3=ruleEnumerationDefinition
+ {
+ $current = $this_EnumerationDefinition_3.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getClassifierDefinitionAccess().getAssociationDefinitionParserRuleCall_4());
+ }
+ this_AssociationDefinition_4=ruleAssociationDefinition
+ {
+ $current = $this_AssociationDefinition_4.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getClassifierDefinitionAccess().getSignalDefinitionParserRuleCall_5());
+ }
+ this_SignalDefinition_5=ruleSignalDefinition
+ {
+ $current = $this_SignalDefinition_5.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getClassifierDefinitionAccess().getActivityDefinitionParserRuleCall_6());
+ }
+ this_ActivityDefinition_6=ruleActivityDefinition
+ {
+ $current = $this_ActivityDefinition_6.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleClassifierDefinitionOrStub
+entryRuleClassifierDefinitionOrStub returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassifierDefinitionOrStubRule()); }
+ iv_ruleClassifierDefinitionOrStub=ruleClassifierDefinitionOrStub
+ { $current=$iv_ruleClassifierDefinitionOrStub.current; }
+ EOF
+;
+
+// Rule ClassifierDefinitionOrStub
+ruleClassifierDefinitionOrStub returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getClassifierDefinitionOrStubAccess().getClassDefinitionOrStubParserRuleCall_0());
+ }
+ this_ClassDefinitionOrStub_0=ruleClassDefinitionOrStub
+ {
+ $current = $this_ClassDefinitionOrStub_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getClassifierDefinitionOrStubAccess().getActiveClassDefinitionOrStubParserRuleCall_1());
+ }
+ this_ActiveClassDefinitionOrStub_1=ruleActiveClassDefinitionOrStub
+ {
+ $current = $this_ActiveClassDefinitionOrStub_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getClassifierDefinitionOrStubAccess().getDataTypeDefinitionOrStubParserRuleCall_2());
+ }
+ this_DataTypeDefinitionOrStub_2=ruleDataTypeDefinitionOrStub
+ {
+ $current = $this_DataTypeDefinitionOrStub_2.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getClassifierDefinitionOrStubAccess().getEnumerationDefinitionOrStubParserRuleCall_3());
+ }
+ this_EnumerationDefinitionOrStub_3=ruleEnumerationDefinitionOrStub
+ {
+ $current = $this_EnumerationDefinitionOrStub_3.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getClassifierDefinitionOrStubAccess().getAssociationDefinitionOrStubParserRuleCall_4());
+ }
+ this_AssociationDefinitionOrStub_4=ruleAssociationDefinitionOrStub
+ {
+ $current = $this_AssociationDefinitionOrStub_4.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getClassifierDefinitionOrStubAccess().getSignalDefinitionOrStubParserRuleCall_5());
+ }
+ this_SignalDefinitionOrStub_5=ruleSignalDefinitionOrStub
+ {
+ $current = $this_SignalDefinitionOrStub_5.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getClassifierDefinitionOrStubAccess().getActivityDefinitionOrStubParserRuleCall_6());
+ }
+ this_ActivityDefinitionOrStub_6=ruleActivityDefinitionOrStub
+ {
+ $current = $this_ActivityDefinitionOrStub_6.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleClassifierSignature
+entryRuleClassifierSignature returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassifierSignatureRule()); }
+ iv_ruleClassifierSignature=ruleClassifierSignature
+ { $current=$iv_ruleClassifierSignature.current; }
+ EOF
+;
+
+// Rule ClassifierSignature
+ruleClassifierSignature returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getClassifierSignatureAccess().getNameNameParserRuleCall_0_0());
+ }
+ lv_name_0_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassifierSignatureRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_0_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getClassifierSignatureAccess().getTemplateParametersTemplateParametersParserRuleCall_1_0());
+ }
+ lv_templateParameters_1_0=ruleTemplateParameters {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassifierSignatureRule());
+ }
+ set(
+ $current,
+ "templateParameters",
+ lv_templateParameters_1_0,
+ "TemplateParameters");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getClassifierSignatureAccess().getSpecializationClauseSpecializationClauseParserRuleCall_2_0());
+ }
+ lv_specializationClause_2_0=ruleSpecializationClause {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassifierSignatureRule());
+ }
+ set(
+ $current,
+ "specializationClause",
+ lv_specializationClause_2_0,
+ "SpecializationClause");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleTemplateParameters
+entryRuleTemplateParameters returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTemplateParametersRule()); }
+ iv_ruleTemplateParameters=ruleTemplateParameters
+ { $current=$iv_ruleTemplateParameters.current; }
+ EOF
+;
+
+// Rule TemplateParameters
+ruleTemplateParameters returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='<'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTemplateParametersAccess().getLessThanSignKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTemplateParametersAccess().getClassifierTemplateParameterClassifierTemplateParameterParserRuleCall_1_0());
+ }
+ lv_classifierTemplateParameter_1_0=ruleClassifierTemplateParameter {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTemplateParametersRule());
+ }
+ add(
+ $current,
+ "classifierTemplateParameter",
+ lv_classifierTemplateParameter_1_0,
+ "ClassifierTemplateParameter");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_2=','
+ {
+ newLeafNode(otherlv_2, grammarAccess.getTemplateParametersAccess().getCommaKeyword_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTemplateParametersAccess().getClassifierTemplateParameterClassifierTemplateParameterParserRuleCall_2_1_0());
+ }
+ lv_classifierTemplateParameter_3_0=ruleClassifierTemplateParameter {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTemplateParametersRule());
+ }
+ add(
+ $current,
+ "classifierTemplateParameter",
+ lv_classifierTemplateParameter_3_0,
+ "ClassifierTemplateParameter");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))* otherlv_4='>'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getTemplateParametersAccess().getGreaterThanSignKeyword_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleClassifierTemplateParameter
+entryRuleClassifierTemplateParameter returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassifierTemplateParameterRule()); }
+ iv_ruleClassifierTemplateParameter=ruleClassifierTemplateParameter
+ { $current=$iv_ruleClassifierTemplateParameter.current; }
+ EOF
+;
+
+// Rule ClassifierTemplateParameter
+ruleClassifierTemplateParameter returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_comment_0_0=RULE_ML_COMMENT
+ {
+ newLeafNode(lv_comment_0_0, grammarAccess.getClassifierTemplateParameterAccess().getCommentML_COMMENTTerminalRuleCall_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getClassifierTemplateParameterRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "comment",
+ lv_comment_0_0,
+ "ML_COMMENT");
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getClassifierTemplateParameterAccess().getNameNameParserRuleCall_1_0());
+ }
+ lv_name_1_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassifierTemplateParameterRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_1_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_2='specializes'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getClassifierTemplateParameterAccess().getSpecializesKeyword_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getClassifierTemplateParameterAccess().getQualifiedNameQualifiedNameParserRuleCall_2_1_0());
+ }
+ lv_qualifiedName_3_0=ruleQualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassifierTemplateParameterRule());
+ }
+ set(
+ $current,
+ "qualifiedName",
+ lv_qualifiedName_3_0,
+ "QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleSpecializationClause
+entryRuleSpecializationClause returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSpecializationClauseRule()); }
+ iv_ruleSpecializationClause=ruleSpecializationClause
+ { $current=$iv_ruleSpecializationClause.current; }
+ EOF
+;
+
+// Rule SpecializationClause
+ruleSpecializationClause returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='specializes'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getSpecializationClauseAccess().getSpecializesKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getSpecializationClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_1_0());
+ }
+ lv_qualifiedNameList_1_0=ruleQualifiedNameList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSpecializationClauseRule());
+ }
+ set(
+ $current,
+ "qualifiedNameList",
+ lv_qualifiedNameList_1_0,
+ "QualifiedNameList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleClassDeclaration
+entryRuleClassDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassDeclarationRule()); }
+ iv_ruleClassDeclaration=ruleClassDeclaration
+ { $current=$iv_ruleClassDeclaration.current; }
+ EOF
+;
+
+// Rule ClassDeclaration
+ruleClassDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_isAbstract_0_0= 'abstract'
+ {
+ newLeafNode(lv_isAbstract_0_0, grammarAccess.getClassDeclarationAccess().getIsAbstractAbstractKeyword_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getClassDeclarationRule());
+ }
+ setWithLastConsumed($current, "isAbstract", true, "abstract");
+ }
+
+)
+)? otherlv_1='class'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getClassDeclarationAccess().getClassKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getClassifierSignatureClassifierSignatureParserRuleCall_2_0());
+ }
+ lv_classifierSignature_2_0=ruleClassifierSignature {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ $current,
+ "classifierSignature",
+ lv_classifierSignature_2_0,
+ "ClassifierSignature");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleClassDefinition
+entryRuleClassDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassDefinitionRule()); }
+ iv_ruleClassDefinition=ruleClassDefinition
+ { $current=$iv_ruleClassDefinition.current; }
+ EOF
+;
+
+// Rule ClassDefinition
+ruleClassDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getClassDefinitionAccess().getClassDeclarationClassDeclarationParserRuleCall_0_0());
+ }
+ lv_classDeclaration_0_0=ruleClassDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDefinitionRule());
+ }
+ set(
+ $current,
+ "classDeclaration",
+ lv_classDeclaration_0_0,
+ "ClassDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getClassDefinitionAccess().getClassBodyClassBodyParserRuleCall_1_0());
+ }
+ lv_classBody_1_0=ruleClassBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDefinitionRule());
+ }
+ set(
+ $current,
+ "classBody",
+ lv_classBody_1_0,
+ "ClassBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleClassDefinitionOrStub
+entryRuleClassDefinitionOrStub returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassDefinitionOrStubRule()); }
+ iv_ruleClassDefinitionOrStub=ruleClassDefinitionOrStub
+ { $current=$iv_ruleClassDefinitionOrStub.current; }
+ EOF
+;
+
+// Rule ClassDefinitionOrStub
+ruleClassDefinitionOrStub returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getClassDefinitionOrStubAccess().getClassDeclarationClassDeclarationParserRuleCall_0_0());
+ }
+ lv_classDeclaration_0_0=ruleClassDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "classDeclaration",
+ lv_classDeclaration_0_0,
+ "ClassDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=';'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getClassDefinitionOrStubAccess().getSemicolonKeyword_1_0());
+ }
+
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getClassDefinitionOrStubAccess().getClassBodyClassBodyParserRuleCall_1_1_0());
+ }
+ lv_classBody_2_0=ruleClassBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "classBody",
+ lv_classBody_2_0,
+ "ClassBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+;
+
+
+
+
+
+// Entry rule entryRuleClassBody
+entryRuleClassBody returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassBodyRule()); }
+ iv_ruleClassBody=ruleClassBody
+ { $current=$iv_ruleClassBody.current; }
+ EOF
+;
+
+// Rule ClassBody
+ruleClassBody returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getClassBodyAccess().getClassBodyAction_0(),
+ $current);
+ }
+) otherlv_1='{'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getClassBodyAccess().getLeftCurlyBracketKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getClassBodyAccess().getClassMemberClassMemberParserRuleCall_2_0());
+ }
+ lv_classMember_2_0=ruleClassMember {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassBodyRule());
+ }
+ add(
+ $current,
+ "classMember",
+ lv_classMember_2_0,
+ "ClassMember");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)* otherlv_3='}'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getClassBodyAccess().getRightCurlyBracketKeyword_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleClassMember
+entryRuleClassMember returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassMemberRule()); }
+ iv_ruleClassMember=ruleClassMember
+ { $current=$iv_ruleClassMember.current; }
+ EOF
+;
+
+// Rule ClassMember
+ruleClassMember returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_comment_0_0=RULE_ML_COMMENT
+ {
+ newLeafNode(lv_comment_0_0, grammarAccess.getClassMemberAccess().getCommentML_COMMENTTerminalRuleCall_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getClassMemberRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "comment",
+ lv_comment_0_0,
+ "ML_COMMENT");
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getClassMemberAccess().getStereotypeAnnotationsStereotypeAnnotationsParserRuleCall_1_0());
+ }
+ lv_stereotypeAnnotations_1_0=ruleStereotypeAnnotations {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassMemberRule());
+ }
+ set(
+ $current,
+ "stereotypeAnnotations",
+ lv_stereotypeAnnotations_1_0,
+ "StereotypeAnnotations");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getClassMemberAccess().getVisibilityIndicatorVisibilityIndicatorParserRuleCall_2_0());
+ }
+ lv_visibilityIndicator_2_0=ruleVisibilityIndicator {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassMemberRule());
+ }
+ set(
+ $current,
+ "visibilityIndicator",
+ lv_visibilityIndicator_2_0,
+ "VisibilityIndicator");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getClassMemberAccess().getClassMemberDefinitionClassMemberDefinitionParserRuleCall_3_0());
+ }
+ lv_classMemberDefinition_3_0=ruleClassMemberDefinition {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassMemberRule());
+ }
+ set(
+ $current,
+ "classMemberDefinition",
+ lv_classMemberDefinition_3_0,
+ "ClassMemberDefinition");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleClassMemberDefinition
+entryRuleClassMemberDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassMemberDefinitionRule()); }
+ iv_ruleClassMemberDefinition=ruleClassMemberDefinition
+ { $current=$iv_ruleClassMemberDefinition.current; }
+ EOF
+;
+
+// Rule ClassMemberDefinition
+ruleClassMemberDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getClassMemberDefinitionAccess().getClassifierDefinitionOrStubParserRuleCall_0());
+ }
+ this_ClassifierDefinitionOrStub_0=ruleClassifierDefinitionOrStub
+ {
+ $current = $this_ClassifierDefinitionOrStub_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getClassMemberDefinitionAccess().getFeatureDefinitionOrStubParserRuleCall_1());
+ }
+ this_FeatureDefinitionOrStub_1=ruleFeatureDefinitionOrStub
+ {
+ $current = $this_FeatureDefinitionOrStub_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleActiveClassDeclaration
+entryRuleActiveClassDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getActiveClassDeclarationRule()); }
+ iv_ruleActiveClassDeclaration=ruleActiveClassDeclaration
+ { $current=$iv_ruleActiveClassDeclaration.current; }
+ EOF
+;
+
+// Rule ActiveClassDeclaration
+ruleActiveClassDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_isAbstract_0_0= 'abstract'
+ {
+ newLeafNode(lv_isAbstract_0_0, grammarAccess.getActiveClassDeclarationAccess().getIsAbstractAbstractKeyword_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getActiveClassDeclarationRule());
+ }
+ setWithLastConsumed($current, "isAbstract", true, "abstract");
+ }
+
+)
+)? otherlv_1='active'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getActiveClassDeclarationAccess().getActiveKeyword_1());
+ }
+ otherlv_2='class'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getActiveClassDeclarationAccess().getClassKeyword_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getActiveClassDeclarationAccess().getClassifierSignatureClassifierSignatureParserRuleCall_3_0());
+ }
+ lv_classifierSignature_3_0=ruleClassifierSignature {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActiveClassDeclarationRule());
+ }
+ set(
+ $current,
+ "classifierSignature",
+ lv_classifierSignature_3_0,
+ "ClassifierSignature");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleActiveClassDefinition
+entryRuleActiveClassDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getActiveClassDefinitionRule()); }
+ iv_ruleActiveClassDefinition=ruleActiveClassDefinition
+ { $current=$iv_ruleActiveClassDefinition.current; }
+ EOF
+;
+
+// Rule ActiveClassDefinition
+ruleActiveClassDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getActiveClassDefinitionAccess().getActiveClassDeclarationActiveClassDeclarationParserRuleCall_0_0());
+ }
+ lv_activeClassDeclaration_0_0=ruleActiveClassDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActiveClassDefinitionRule());
+ }
+ set(
+ $current,
+ "activeClassDeclaration",
+ lv_activeClassDeclaration_0_0,
+ "ActiveClassDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getActiveClassDefinitionAccess().getActiveClassBodyActiveClassBodyParserRuleCall_1_0());
+ }
+ lv_activeClassBody_1_0=ruleActiveClassBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActiveClassDefinitionRule());
+ }
+ set(
+ $current,
+ "activeClassBody",
+ lv_activeClassBody_1_0,
+ "ActiveClassBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleActiveClassDefinitionOrStub
+entryRuleActiveClassDefinitionOrStub returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getActiveClassDefinitionOrStubRule()); }
+ iv_ruleActiveClassDefinitionOrStub=ruleActiveClassDefinitionOrStub
+ { $current=$iv_ruleActiveClassDefinitionOrStub.current; }
+ EOF
+;
+
+// Rule ActiveClassDefinitionOrStub
+ruleActiveClassDefinitionOrStub returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getActiveClassDefinitionOrStubAccess().getActiveClassDeclarationActiveClassDeclarationParserRuleCall_0_0());
+ }
+ lv_activeClassDeclaration_0_0=ruleActiveClassDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActiveClassDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "activeClassDeclaration",
+ lv_activeClassDeclaration_0_0,
+ "ActiveClassDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=';'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getActiveClassDefinitionOrStubAccess().getSemicolonKeyword_1_0());
+ }
+
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getActiveClassDefinitionOrStubAccess().getActiveClassBodyActiveClassBodyParserRuleCall_1_1_0());
+ }
+ lv_activeClassBody_2_0=ruleActiveClassBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActiveClassDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "activeClassBody",
+ lv_activeClassBody_2_0,
+ "ActiveClassBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+;
+
+
+
+
+
+// Entry rule entryRuleActiveClassBody
+entryRuleActiveClassBody returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getActiveClassBodyRule()); }
+ iv_ruleActiveClassBody=ruleActiveClassBody
+ { $current=$iv_ruleActiveClassBody.current; }
+ EOF
+;
+
+// Rule ActiveClassBody
+ruleActiveClassBody returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getActiveClassBodyAccess().getActiveClassBodyAction_0(),
+ $current);
+ }
+) otherlv_1='{'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getActiveClassBodyAccess().getLeftCurlyBracketKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getActiveClassBodyAccess().getActiveClassMemberActiveClassMemberParserRuleCall_2_0());
+ }
+ lv_activeClassMember_2_0=ruleActiveClassMember {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActiveClassBodyRule());
+ }
+ add(
+ $current,
+ "activeClassMember",
+ lv_activeClassMember_2_0,
+ "ActiveClassMember");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)* otherlv_3='}'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getActiveClassBodyAccess().getRightCurlyBracketKeyword_3());
+ }
+( otherlv_4='do'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getActiveClassBodyAccess().getDoKeyword_4_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getActiveClassBodyAccess().getBehaviorClasueBehaviorClauseParserRuleCall_4_1_0());
+ }
+ lv_behaviorClasue_5_0=ruleBehaviorClause {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActiveClassBodyRule());
+ }
+ set(
+ $current,
+ "behaviorClasue",
+ lv_behaviorClasue_5_0,
+ "BehaviorClause");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleBehaviorClause
+entryRuleBehaviorClause returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getBehaviorClauseRule()); }
+ iv_ruleBehaviorClause=ruleBehaviorClause
+ { $current=$iv_ruleBehaviorClause.current; }
+ EOF
+;
+
+// Rule BehaviorClause
+ruleBehaviorClause returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getBehaviorClauseAccess().getBlockBlockParserRuleCall_0_0());
+ }
+ lv_block_0_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getBehaviorClauseRule());
+ }
+ set(
+ $current,
+ "block",
+ lv_block_0_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getBehaviorClauseAccess().getNameNameParserRuleCall_1_0());
+ }
+ lv_name_1_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getBehaviorClauseRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_1_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleActiveClassMember
+entryRuleActiveClassMember returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getActiveClassMemberRule()); }
+ iv_ruleActiveClassMember=ruleActiveClassMember
+ { $current=$iv_ruleActiveClassMember.current; }
+ EOF
+;
+
+// Rule ActiveClassMember
+ruleActiveClassMember returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_comment_0_0=RULE_ML_COMMENT
+ {
+ newLeafNode(lv_comment_0_0, grammarAccess.getActiveClassMemberAccess().getCommentML_COMMENTTerminalRuleCall_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getActiveClassMemberRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "comment",
+ lv_comment_0_0,
+ "ML_COMMENT");
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getActiveClassMemberAccess().getStereotypeAnnotationsStereotypeAnnotationsParserRuleCall_1_0());
+ }
+ lv_stereotypeAnnotations_1_0=ruleStereotypeAnnotations {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActiveClassMemberRule());
+ }
+ set(
+ $current,
+ "stereotypeAnnotations",
+ lv_stereotypeAnnotations_1_0,
+ "StereotypeAnnotations");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getActiveClassMemberAccess().getVisibilityIndicatorVisibilityIndicatorParserRuleCall_2_0());
+ }
+ lv_visibilityIndicator_2_0=ruleVisibilityIndicator {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActiveClassMemberRule());
+ }
+ set(
+ $current,
+ "visibilityIndicator",
+ lv_visibilityIndicator_2_0,
+ "VisibilityIndicator");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getActiveClassMemberAccess().getActiveClassMemberDefinitionActiveClassMemberDefinitionParserRuleCall_3_0());
+ }
+ lv_activeClassMemberDefinition_3_0=ruleActiveClassMemberDefinition {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActiveClassMemberRule());
+ }
+ set(
+ $current,
+ "activeClassMemberDefinition",
+ lv_activeClassMemberDefinition_3_0,
+ "ActiveClassMemberDefinition");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleActiveClassMemberDefinition
+entryRuleActiveClassMemberDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getActiveClassMemberDefinitionRule()); }
+ iv_ruleActiveClassMemberDefinition=ruleActiveClassMemberDefinition
+ { $current=$iv_ruleActiveClassMemberDefinition.current; }
+ EOF
+;
+
+// Rule ActiveClassMemberDefinition
+ruleActiveClassMemberDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getActiveClassMemberDefinitionAccess().getClassMemberDefinitionParserRuleCall_0());
+ }
+ this_ClassMemberDefinition_0=ruleClassMemberDefinition
+ {
+ $current = $this_ClassMemberDefinition_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getActiveClassMemberDefinitionAccess().getActiveFeatureDefinitionOrStubParserRuleCall_1());
+ }
+ this_ActiveFeatureDefinitionOrStub_1=ruleActiveFeatureDefinitionOrStub
+ {
+ $current = $this_ActiveFeatureDefinitionOrStub_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleDataTypeDeclaration
+entryRuleDataTypeDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getDataTypeDeclarationRule()); }
+ iv_ruleDataTypeDeclaration=ruleDataTypeDeclaration
+ { $current=$iv_ruleDataTypeDeclaration.current; }
+ EOF
+;
+
+// Rule DataTypeDeclaration
+ruleDataTypeDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_isAbstract_0_0= 'abstract'
+ {
+ newLeafNode(lv_isAbstract_0_0, grammarAccess.getDataTypeDeclarationAccess().getIsAbstractAbstractKeyword_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getDataTypeDeclarationRule());
+ }
+ setWithLastConsumed($current, "isAbstract", true, "abstract");
+ }
+
+)
+)? otherlv_1='datatype'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getDataTypeDeclarationAccess().getDatatypeKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getDataTypeDeclarationAccess().getClassifierSignatureClassifierSignatureParserRuleCall_2_0());
+ }
+ lv_classifierSignature_2_0=ruleClassifierSignature {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDataTypeDeclarationRule());
+ }
+ set(
+ $current,
+ "classifierSignature",
+ lv_classifierSignature_2_0,
+ "ClassifierSignature");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleDataTypeDefinition
+entryRuleDataTypeDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getDataTypeDefinitionRule()); }
+ iv_ruleDataTypeDefinition=ruleDataTypeDefinition
+ { $current=$iv_ruleDataTypeDefinition.current; }
+ EOF
+;
+
+// Rule DataTypeDefinition
+ruleDataTypeDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getDataTypeDefinitionAccess().getDataTypeDeclarationDataTypeDeclarationParserRuleCall_0_0());
+ }
+ lv_dataTypeDeclaration_0_0=ruleDataTypeDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDataTypeDefinitionRule());
+ }
+ set(
+ $current,
+ "dataTypeDeclaration",
+ lv_dataTypeDeclaration_0_0,
+ "DataTypeDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getDataTypeDefinitionAccess().getStructureBodyStructuredBodyParserRuleCall_1_0());
+ }
+ lv_structureBody_1_0=ruleStructuredBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDataTypeDefinitionRule());
+ }
+ set(
+ $current,
+ "structureBody",
+ lv_structureBody_1_0,
+ "StructuredBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleDataTypeDefinitionOrStub
+entryRuleDataTypeDefinitionOrStub returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getDataTypeDefinitionOrStubRule()); }
+ iv_ruleDataTypeDefinitionOrStub=ruleDataTypeDefinitionOrStub
+ { $current=$iv_ruleDataTypeDefinitionOrStub.current; }
+ EOF
+;
+
+// Rule DataTypeDefinitionOrStub
+ruleDataTypeDefinitionOrStub returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getDataTypeDefinitionOrStubAccess().getDataTypeDeclarationDataTypeDeclarationParserRuleCall_0_0());
+ }
+ lv_dataTypeDeclaration_0_0=ruleDataTypeDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDataTypeDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "dataTypeDeclaration",
+ lv_dataTypeDeclaration_0_0,
+ "DataTypeDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=';'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getDataTypeDefinitionOrStubAccess().getSemicolonKeyword_1_0());
+ }
+
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getDataTypeDefinitionOrStubAccess().getStructureBodyStructuredBodyParserRuleCall_1_1_0());
+ }
+ lv_structureBody_2_0=ruleStructuredBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDataTypeDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "structureBody",
+ lv_structureBody_2_0,
+ "StructuredBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+;
+
+
+
+
+
+// Entry rule entryRuleStructuredBody
+entryRuleStructuredBody returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getStructuredBodyRule()); }
+ iv_ruleStructuredBody=ruleStructuredBody
+ { $current=$iv_ruleStructuredBody.current; }
+ EOF
+;
+
+// Rule StructuredBody
+ruleStructuredBody returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getStructuredBodyAccess().getStructuredBodyAction_0(),
+ $current);
+ }
+) otherlv_1='{'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getStructuredBodyAccess().getLeftCurlyBracketKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getStructuredBodyAccess().getStructuredMemberStructuredMemberParserRuleCall_2_0());
+ }
+ lv_structuredMember_2_0=ruleStructuredMember {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getStructuredBodyRule());
+ }
+ add(
+ $current,
+ "structuredMember",
+ lv_structuredMember_2_0,
+ "StructuredMember");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)* otherlv_3='}'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getStructuredBodyAccess().getRightCurlyBracketKeyword_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleStructuredMember
+entryRuleStructuredMember returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getStructuredMemberRule()); }
+ iv_ruleStructuredMember=ruleStructuredMember
+ { $current=$iv_ruleStructuredMember.current; }
+ EOF
+;
+
+// Rule StructuredMember
+ruleStructuredMember returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_comment_0_0=RULE_ML_COMMENT
+ {
+ newLeafNode(lv_comment_0_0, grammarAccess.getStructuredMemberAccess().getCommentML_COMMENTTerminalRuleCall_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getStructuredMemberRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "comment",
+ lv_comment_0_0,
+ "ML_COMMENT");
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getStructuredMemberAccess().getStreotypeAnnotationsStereotypeAnnotationsParserRuleCall_1_0());
+ }
+ lv_streotypeAnnotations_1_0=ruleStereotypeAnnotations {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getStructuredMemberRule());
+ }
+ set(
+ $current,
+ "streotypeAnnotations",
+ lv_streotypeAnnotations_1_0,
+ "StereotypeAnnotations");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ lv_isPublic_2_0= 'public'
+ {
+ newLeafNode(lv_isPublic_2_0, grammarAccess.getStructuredMemberAccess().getIsPublicPublicKeyword_2_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getStructuredMemberRule());
+ }
+ setWithLastConsumed($current, "isPublic", true, "public");
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getStructuredMemberAccess().getPropertyDefinitionPropertyDefinitionParserRuleCall_3_0());
+ }
+ lv_propertyDefinition_3_0=rulePropertyDefinition {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getStructuredMemberRule());
+ }
+ set(
+ $current,
+ "propertyDefinition",
+ lv_propertyDefinition_3_0,
+ "PropertyDefinition");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleAssociationDeclaration
+entryRuleAssociationDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssociationDeclarationRule()); }
+ iv_ruleAssociationDeclaration=ruleAssociationDeclaration
+ { $current=$iv_ruleAssociationDeclaration.current; }
+ EOF
+;
+
+// Rule AssociationDeclaration
+ruleAssociationDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_isAbstract_0_0= 'abstract'
+ {
+ newLeafNode(lv_isAbstract_0_0, grammarAccess.getAssociationDeclarationAccess().getIsAbstractAbstractKeyword_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getAssociationDeclarationRule());
+ }
+ setWithLastConsumed($current, "isAbstract", true, "abstract");
+ }
+
+)
+)? otherlv_1='assoc'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getAssociationDeclarationAccess().getAssocKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getAssociationDeclarationAccess().getClassifierSignatureClassifierSignatureParserRuleCall_2_0());
+ }
+ lv_classifierSignature_2_0=ruleClassifierSignature {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssociationDeclarationRule());
+ }
+ set(
+ $current,
+ "classifierSignature",
+ lv_classifierSignature_2_0,
+ "ClassifierSignature");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleAssociationDefinition
+entryRuleAssociationDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssociationDefinitionRule()); }
+ iv_ruleAssociationDefinition=ruleAssociationDefinition
+ { $current=$iv_ruleAssociationDefinition.current; }
+ EOF
+;
+
+// Rule AssociationDefinition
+ruleAssociationDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getAssociationDefinitionAccess().getAssociationDeclarationAssociationDeclarationParserRuleCall_0_0());
+ }
+ lv_associationDeclaration_0_0=ruleAssociationDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssociationDefinitionRule());
+ }
+ set(
+ $current,
+ "associationDeclaration",
+ lv_associationDeclaration_0_0,
+ "AssociationDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getAssociationDefinitionAccess().getStructuredBodyStructuredBodyParserRuleCall_1_0());
+ }
+ lv_structuredBody_1_0=ruleStructuredBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssociationDefinitionRule());
+ }
+ set(
+ $current,
+ "structuredBody",
+ lv_structuredBody_1_0,
+ "StructuredBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleAssociationDefinitionOrStub
+entryRuleAssociationDefinitionOrStub returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssociationDefinitionOrStubRule()); }
+ iv_ruleAssociationDefinitionOrStub=ruleAssociationDefinitionOrStub
+ { $current=$iv_ruleAssociationDefinitionOrStub.current; }
+ EOF
+;
+
+// Rule AssociationDefinitionOrStub
+ruleAssociationDefinitionOrStub returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getAssociationDefinitionOrStubAccess().getAssociationDeclarationAssociationDeclarationParserRuleCall_0_0());
+ }
+ lv_associationDeclaration_0_0=ruleAssociationDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssociationDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "associationDeclaration",
+ lv_associationDeclaration_0_0,
+ "AssociationDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=';'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getAssociationDefinitionOrStubAccess().getSemicolonKeyword_1_0());
+ }
+
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getAssociationDefinitionOrStubAccess().getStructuredBodyStructuredBodyParserRuleCall_1_1_0());
+ }
+ lv_structuredBody_2_0=ruleStructuredBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssociationDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "structuredBody",
+ lv_structuredBody_2_0,
+ "StructuredBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+;
+
+
+
+
+
+// Entry rule entryRuleEnumerationDeclaration
+entryRuleEnumerationDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getEnumerationDeclarationRule()); }
+ iv_ruleEnumerationDeclaration=ruleEnumerationDeclaration
+ { $current=$iv_ruleEnumerationDeclaration.current; }
+ EOF
+;
+
+// Rule EnumerationDeclaration
+ruleEnumerationDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='enum'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getEnumerationDeclarationAccess().getEnumKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getEnumerationDeclarationAccess().getNameNameParserRuleCall_1_0());
+ }
+ lv_name_1_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEnumerationDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_1_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getEnumerationDeclarationAccess().getSpecializationClauseSpecializationClauseParserRuleCall_2_0());
+ }
+ lv_specializationClause_2_0=ruleSpecializationClause {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEnumerationDeclarationRule());
+ }
+ set(
+ $current,
+ "specializationClause",
+ lv_specializationClause_2_0,
+ "SpecializationClause");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleEnumerationDefinition
+entryRuleEnumerationDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getEnumerationDefinitionRule()); }
+ iv_ruleEnumerationDefinition=ruleEnumerationDefinition
+ { $current=$iv_ruleEnumerationDefinition.current; }
+ EOF
+;
+
+// Rule EnumerationDefinition
+ruleEnumerationDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getEnumerationDefinitionAccess().getEnumerationClauseEnumerationDeclarationParserRuleCall_0_0());
+ }
+ lv_enumerationClause_0_0=ruleEnumerationDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEnumerationDefinitionRule());
+ }
+ set(
+ $current,
+ "enumerationClause",
+ lv_enumerationClause_0_0,
+ "EnumerationDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getEnumerationDefinitionAccess().getEnumerationBodyEnumerationBodyParserRuleCall_1_0());
+ }
+ lv_enumerationBody_1_0=ruleEnumerationBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEnumerationDefinitionRule());
+ }
+ set(
+ $current,
+ "enumerationBody",
+ lv_enumerationBody_1_0,
+ "EnumerationBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleEnumerationDefinitionOrStub
+entryRuleEnumerationDefinitionOrStub returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getEnumerationDefinitionOrStubRule()); }
+ iv_ruleEnumerationDefinitionOrStub=ruleEnumerationDefinitionOrStub
+ { $current=$iv_ruleEnumerationDefinitionOrStub.current; }
+ EOF
+;
+
+// Rule EnumerationDefinitionOrStub
+ruleEnumerationDefinitionOrStub returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getEnumerationDefinitionOrStubAccess().getEnumerationDeclarationEnumerationDeclarationParserRuleCall_0_0());
+ }
+ lv_enumerationDeclaration_0_0=ruleEnumerationDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEnumerationDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "enumerationDeclaration",
+ lv_enumerationDeclaration_0_0,
+ "EnumerationDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=';'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getEnumerationDefinitionOrStubAccess().getSemicolonKeyword_1_0());
+ }
+
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getEnumerationDefinitionOrStubAccess().getEnumerationBodyEnumerationBodyParserRuleCall_1_1_0());
+ }
+ lv_enumerationBody_2_0=ruleEnumerationBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEnumerationDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "enumerationBody",
+ lv_enumerationBody_2_0,
+ "EnumerationBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+;
+
+
+
+
+
+// Entry rule entryRuleEnumerationBody
+entryRuleEnumerationBody returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getEnumerationBodyRule()); }
+ iv_ruleEnumerationBody=ruleEnumerationBody
+ { $current=$iv_ruleEnumerationBody.current; }
+ EOF
+;
+
+// Rule EnumerationBody
+ruleEnumerationBody returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='{'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getEnumerationBodyAccess().getLeftCurlyBracketKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getEnumerationBodyAccess().getEnumerationLiteralNameEnumerationLiteralNameParserRuleCall_1_0());
+ }
+ lv_enumerationLiteralName_1_0=ruleEnumerationLiteralName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEnumerationBodyRule());
+ }
+ add(
+ $current,
+ "enumerationLiteralName",
+ lv_enumerationLiteralName_1_0,
+ "EnumerationLiteralName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_2=','
+ {
+ newLeafNode(otherlv_2, grammarAccess.getEnumerationBodyAccess().getCommaKeyword_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getEnumerationBodyAccess().getEnumerationLiteralNameEnumerationLiteralNameParserRuleCall_2_1_0());
+ }
+ lv_enumerationLiteralName_3_0=ruleEnumerationLiteralName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEnumerationBodyRule());
+ }
+ add(
+ $current,
+ "enumerationLiteralName",
+ lv_enumerationLiteralName_3_0,
+ "EnumerationLiteralName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))* otherlv_4='}'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getEnumerationBodyAccess().getRightCurlyBracketKeyword_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleEnumerationLiteralName
+entryRuleEnumerationLiteralName returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getEnumerationLiteralNameRule()); }
+ iv_ruleEnumerationLiteralName=ruleEnumerationLiteralName
+ { $current=$iv_ruleEnumerationLiteralName.current; }
+ EOF
+;
+
+// Rule EnumerationLiteralName
+ruleEnumerationLiteralName returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_comment_0_0=RULE_ML_COMMENT
+ {
+ newLeafNode(lv_comment_0_0, grammarAccess.getEnumerationLiteralNameAccess().getCommentML_COMMENTTerminalRuleCall_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getEnumerationLiteralNameRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "comment",
+ lv_comment_0_0,
+ "ML_COMMENT");
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getEnumerationLiteralNameAccess().getNameNameParserRuleCall_1_0());
+ }
+ lv_name_1_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEnumerationLiteralNameRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_1_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleSignalDeclaration
+entryRuleSignalDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSignalDeclarationRule()); }
+ iv_ruleSignalDeclaration=ruleSignalDeclaration
+ { $current=$iv_ruleSignalDeclaration.current; }
+ EOF
+;
+
+// Rule SignalDeclaration
+ruleSignalDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_isAbstract_0_0= 'abstract'
+ {
+ newLeafNode(lv_isAbstract_0_0, grammarAccess.getSignalDeclarationAccess().getIsAbstractAbstractKeyword_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getSignalDeclarationRule());
+ }
+ setWithLastConsumed($current, "isAbstract", true, "abstract");
+ }
+
+)
+)? otherlv_1='signal'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getSignalDeclarationAccess().getSignalKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getSignalDeclarationAccess().getClassifierSignatureClassifierSignatureParserRuleCall_2_0());
+ }
+ lv_classifierSignature_2_0=ruleClassifierSignature {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSignalDeclarationRule());
+ }
+ set(
+ $current,
+ "classifierSignature",
+ lv_classifierSignature_2_0,
+ "ClassifierSignature");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleSignalDefinition
+entryRuleSignalDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSignalDefinitionRule()); }
+ iv_ruleSignalDefinition=ruleSignalDefinition
+ { $current=$iv_ruleSignalDefinition.current; }
+ EOF
+;
+
+// Rule SignalDefinition
+ruleSignalDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getSignalDefinitionAccess().getSignalDeclarationSignalDeclarationParserRuleCall_0_0());
+ }
+ lv_signalDeclaration_0_0=ruleSignalDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSignalDefinitionRule());
+ }
+ set(
+ $current,
+ "signalDeclaration",
+ lv_signalDeclaration_0_0,
+ "SignalDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getSignalDefinitionAccess().getStructuredBodyStructuredBodyParserRuleCall_1_0());
+ }
+ lv_structuredBody_1_0=ruleStructuredBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSignalDefinitionRule());
+ }
+ set(
+ $current,
+ "structuredBody",
+ lv_structuredBody_1_0,
+ "StructuredBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleSignalDefinitionOrStub
+entryRuleSignalDefinitionOrStub returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSignalDefinitionOrStubRule()); }
+ iv_ruleSignalDefinitionOrStub=ruleSignalDefinitionOrStub
+ { $current=$iv_ruleSignalDefinitionOrStub.current; }
+ EOF
+;
+
+// Rule SignalDefinitionOrStub
+ruleSignalDefinitionOrStub returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getSignalDefinitionOrStubAccess().getSignalDeclarationSignalDeclarationParserRuleCall_0_0());
+ }
+ lv_signalDeclaration_0_0=ruleSignalDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSignalDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "signalDeclaration",
+ lv_signalDeclaration_0_0,
+ "SignalDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=';'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getSignalDefinitionOrStubAccess().getSemicolonKeyword_1_0());
+ }
+
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getSignalDefinitionOrStubAccess().getStructuredBodyStructuredBodyParserRuleCall_1_1_0());
+ }
+ lv_structuredBody_2_0=ruleStructuredBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSignalDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "structuredBody",
+ lv_structuredBody_2_0,
+ "StructuredBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+;
+
+
+
+
+
+// Entry rule entryRuleActivityDeclaration
+entryRuleActivityDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getActivityDeclarationRule()); }
+ iv_ruleActivityDeclaration=ruleActivityDeclaration
+ { $current=$iv_ruleActivityDeclaration.current; }
+ EOF
+;
+
+// Rule ActivityDeclaration
+ruleActivityDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='activity'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getActivityDeclarationAccess().getActivityKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getActivityDeclarationAccess().getNameNameParserRuleCall_1_0());
+ }
+ lv_name_1_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActivityDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_1_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getActivityDeclarationAccess().getTemplateParametersTemplateParametersParserRuleCall_2_0());
+ }
+ lv_templateParameters_2_0=ruleTemplateParameters {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActivityDeclarationRule());
+ }
+ set(
+ $current,
+ "templateParameters",
+ lv_templateParameters_2_0,
+ "TemplateParameters");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getActivityDeclarationAccess().getFormalParametersFormalParametersParserRuleCall_3_0());
+ }
+ lv_formalParameters_3_0=ruleFormalParameters {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActivityDeclarationRule());
+ }
+ set(
+ $current,
+ "formalParameters",
+ lv_formalParameters_3_0,
+ "FormalParameters");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_4=':'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getActivityDeclarationAccess().getColonKeyword_4_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getActivityDeclarationAccess().getTypePartTypePartParserRuleCall_4_1_0());
+ }
+ lv_typePart_5_0=ruleTypePart {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActivityDeclarationRule());
+ }
+ set(
+ $current,
+ "typePart",
+ lv_typePart_5_0,
+ "TypePart");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleActivityDefinition
+entryRuleActivityDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getActivityDefinitionRule()); }
+ iv_ruleActivityDefinition=ruleActivityDefinition
+ { $current=$iv_ruleActivityDefinition.current; }
+ EOF
+;
+
+// Rule ActivityDefinition
+ruleActivityDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getActivityDefinitionAccess().getActivityDeclarationActivityDeclarationParserRuleCall_0_0());
+ }
+ lv_activityDeclaration_0_0=ruleActivityDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActivityDefinitionRule());
+ }
+ set(
+ $current,
+ "activityDeclaration",
+ lv_activityDeclaration_0_0,
+ "ActivityDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getActivityDefinitionAccess().getBlockBlockParserRuleCall_1_0());
+ }
+ lv_block_1_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActivityDefinitionRule());
+ }
+ set(
+ $current,
+ "block",
+ lv_block_1_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleActivityDefinitionOrStub
+entryRuleActivityDefinitionOrStub returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getActivityDefinitionOrStubRule()); }
+ iv_ruleActivityDefinitionOrStub=ruleActivityDefinitionOrStub
+ { $current=$iv_ruleActivityDefinitionOrStub.current; }
+ EOF
+;
+
+// Rule ActivityDefinitionOrStub
+ruleActivityDefinitionOrStub returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getActivityDefinitionOrStubAccess().getActivityDeclarationActivityDeclarationParserRuleCall_0_0());
+ }
+ lv_activityDeclaration_0_0=ruleActivityDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActivityDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "activityDeclaration",
+ lv_activityDeclaration_0_0,
+ "ActivityDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=';'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getActivityDefinitionOrStubAccess().getSemicolonKeyword_1_0());
+ }
+
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getActivityDefinitionOrStubAccess().getBlockBlockParserRuleCall_1_1_0());
+ }
+ lv_block_2_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getActivityDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "block",
+ lv_block_2_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+;
+
+
+
+
+
+// Entry rule entryRuleFormalParameters
+entryRuleFormalParameters returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getFormalParametersRule()); }
+ iv_ruleFormalParameters=ruleFormalParameters
+ { $current=$iv_ruleFormalParameters.current; }
+ EOF
+;
+
+// Rule FormalParameters
+ruleFormalParameters returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getFormalParametersAccess().getFormalParametersAction_0(),
+ $current);
+ }
+) otherlv_1='('
+ {
+ newLeafNode(otherlv_1, grammarAccess.getFormalParametersAccess().getLeftParenthesisKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getFormalParametersAccess().getFormalParameterListFormalParameterListParserRuleCall_2_0());
+ }
+ lv_formalParameterList_2_0=ruleFormalParameterList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFormalParametersRule());
+ }
+ set(
+ $current,
+ "formalParameterList",
+ lv_formalParameterList_2_0,
+ "FormalParameterList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)? otherlv_3=')'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getFormalParametersAccess().getRightParenthesisKeyword_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleFormalParameterList
+entryRuleFormalParameterList returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getFormalParameterListRule()); }
+ iv_ruleFormalParameterList=ruleFormalParameterList
+ { $current=$iv_ruleFormalParameterList.current; }
+ EOF
+;
+
+// Rule FormalParameterList
+ruleFormalParameterList returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getFormalParameterListAccess().getFormalParameterFormalParameterParserRuleCall_0_0());
+ }
+ lv_formalParameter_0_0=ruleFormalParameter {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFormalParameterListRule());
+ }
+ add(
+ $current,
+ "formalParameter",
+ lv_formalParameter_0_0,
+ "FormalParameter");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=','
+ {
+ newLeafNode(otherlv_1, grammarAccess.getFormalParameterListAccess().getCommaKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getFormalParameterListAccess().getFormalParameterFormalParameterParserRuleCall_1_1_0());
+ }
+ lv_formalParameter_2_0=ruleFormalParameter {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFormalParameterListRule());
+ }
+ add(
+ $current,
+ "formalParameter",
+ lv_formalParameter_2_0,
+ "FormalParameter");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleFormalParameter
+entryRuleFormalParameter returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getFormalParameterRule()); }
+ iv_ruleFormalParameter=ruleFormalParameter
+ { $current=$iv_ruleFormalParameter.current; }
+ EOF
+;
+
+// Rule FormalParameter
+ruleFormalParameter returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_comment_0_0=RULE_ML_COMMENT
+ {
+ newLeafNode(lv_comment_0_0, grammarAccess.getFormalParameterAccess().getCommentML_COMMENTTerminalRuleCall_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getFormalParameterRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "comment",
+ lv_comment_0_0,
+ "ML_COMMENT");
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getFormalParameterAccess().getStereotypeAnnotationsStereotypeAnnotationsParserRuleCall_1_0());
+ }
+ lv_stereotypeAnnotations_1_0=ruleStereotypeAnnotations {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFormalParameterRule());
+ }
+ set(
+ $current,
+ "stereotypeAnnotations",
+ lv_stereotypeAnnotations_1_0,
+ "StereotypeAnnotations");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getFormalParameterAccess().getParameterDirectionParameterDirectionEnumRuleCall_2_0());
+ }
+ lv_parameterDirection_2_0=ruleParameterDirection {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFormalParameterRule());
+ }
+ set(
+ $current,
+ "parameterDirection",
+ lv_parameterDirection_2_0,
+ "ParameterDirection");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getFormalParameterAccess().getNameNameParserRuleCall_3_0());
+ }
+ lv_name_3_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFormalParameterRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_3_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_4=':'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getFormalParameterAccess().getColonKeyword_4());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getFormalParameterAccess().getTypePartTypePartParserRuleCall_5_0());
+ }
+ lv_typePart_5_0=ruleTypePart {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFormalParameterRule());
+ }
+ set(
+ $current,
+ "typePart",
+ lv_typePart_5_0,
+ "TypePart");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleFeatureDefinitionOrStub
+entryRuleFeatureDefinitionOrStub returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getFeatureDefinitionOrStubRule()); }
+ iv_ruleFeatureDefinitionOrStub=ruleFeatureDefinitionOrStub
+ { $current=$iv_ruleFeatureDefinitionOrStub.current; }
+ EOF
+;
+
+// Rule FeatureDefinitionOrStub
+ruleFeatureDefinitionOrStub returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getFeatureDefinitionOrStubAccess().getAttributeDefinitionParserRuleCall_0());
+ }
+ this_AttributeDefinition_0=ruleAttributeDefinition
+ {
+ $current = $this_AttributeDefinition_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getFeatureDefinitionOrStubAccess().getOperationDefinitionOrStubParserRuleCall_1());
+ }
+ this_OperationDefinitionOrStub_1=ruleOperationDefinitionOrStub
+ {
+ $current = $this_OperationDefinitionOrStub_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleActiveFeatureDefinitionOrStub
+entryRuleActiveFeatureDefinitionOrStub returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getActiveFeatureDefinitionOrStubRule()); }
+ iv_ruleActiveFeatureDefinitionOrStub=ruleActiveFeatureDefinitionOrStub
+ { $current=$iv_ruleActiveFeatureDefinitionOrStub.current; }
+ EOF
+;
+
+// Rule ActiveFeatureDefinitionOrStub
+ruleActiveFeatureDefinitionOrStub returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getActiveFeatureDefinitionOrStubAccess().getReceptionDefinitionParserRuleCall_0());
+ }
+ this_ReceptionDefinition_0=ruleReceptionDefinition
+ {
+ $current = $this_ReceptionDefinition_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getActiveFeatureDefinitionOrStubAccess().getSignalReceptionDefinitionOrStubParserRuleCall_1());
+ }
+ this_SignalReceptionDefinitionOrStub_1=ruleSignalReceptionDefinitionOrStub
+ {
+ $current = $this_SignalReceptionDefinitionOrStub_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRulePropertyDefinition
+entryRulePropertyDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyDefinitionRule()); }
+ iv_rulePropertyDefinition=rulePropertyDefinition
+ { $current=$iv_rulePropertyDefinition.current; }
+ EOF
+;
+
+// Rule PropertyDefinition
+rulePropertyDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyDefinitionAccess().getPropertyDeclarationPropertyDeclarationParserRuleCall_0_0());
+ }
+ lv_propertyDeclaration_0_0=rulePropertyDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPropertyDefinitionRule());
+ }
+ set(
+ $current,
+ "propertyDeclaration",
+ lv_propertyDeclaration_0_0,
+ "PropertyDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_1=';'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPropertyDefinitionAccess().getSemicolonKeyword_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleAttributeDefinition
+entryRuleAttributeDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAttributeDefinitionRule()); }
+ iv_ruleAttributeDefinition=ruleAttributeDefinition
+ { $current=$iv_ruleAttributeDefinition.current; }
+ EOF
+;
+
+// Rule AttributeDefinition
+ruleAttributeDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getAttributeDefinitionAccess().getPropertyDeclarationPropertyDeclarationParserRuleCall_0_0());
+ }
+ lv_propertyDeclaration_0_0=rulePropertyDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAttributeDefinitionRule());
+ }
+ set(
+ $current,
+ "propertyDeclaration",
+ lv_propertyDeclaration_0_0,
+ "PropertyDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getAttributeDefinitionAccess().getAttributeInitializerAttributeInitializerParserRuleCall_1_0());
+ }
+ lv_attributeInitializer_1_0=ruleAttributeInitializer {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAttributeDefinitionRule());
+ }
+ set(
+ $current,
+ "attributeInitializer",
+ lv_attributeInitializer_1_0,
+ "AttributeInitializer");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)? otherlv_2=';'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getAttributeDefinitionAccess().getSemicolonKeyword_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleAttributeInitializer
+entryRuleAttributeInitializer returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAttributeInitializerRule()); }
+ iv_ruleAttributeInitializer=ruleAttributeInitializer
+ { $current=$iv_ruleAttributeInitializer.current; }
+ EOF
+;
+
+// Rule AttributeInitializer
+ruleAttributeInitializer returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='='
+ {
+ newLeafNode(otherlv_0, grammarAccess.getAttributeInitializerAccess().getEqualsSignKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getAttributeInitializerAccess().getInitializationExpressionInitializationExpressionParserRuleCall_1_0());
+ }
+ lv_initializationExpression_1_0=ruleInitializationExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAttributeInitializerRule());
+ }
+ set(
+ $current,
+ "initializationExpression",
+ lv_initializationExpression_1_0,
+ "InitializationExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRulePropertyDeclaration
+entryRulePropertyDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyDeclarationRule()); }
+ iv_rulePropertyDeclaration=rulePropertyDeclaration
+ { $current=$iv_rulePropertyDeclaration.current; }
+ EOF
+;
+
+// Rule PropertyDeclaration
+rulePropertyDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyDeclarationAccess().getNameNameParserRuleCall_0_0());
+ }
+ lv_name_0_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPropertyDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_0_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_1=':'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPropertyDeclarationAccess().getColonKeyword_1());
+ }
+(
+(
+ lv_isComposite_2_0= 'compose'
+ {
+ newLeafNode(lv_isComposite_2_0, grammarAccess.getPropertyDeclarationAccess().getIsCompositeComposeKeyword_2_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getPropertyDeclarationRule());
+ }
+ setWithLastConsumed($current, "isComposite", true, "compose");
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyDeclarationAccess().getTypePartTypePartParserRuleCall_3_0());
+ }
+ lv_typePart_3_0=ruleTypePart {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPropertyDeclarationRule());
+ }
+ set(
+ $current,
+ "typePart",
+ lv_typePart_3_0,
+ "TypePart");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTypePart
+entryRuleTypePart returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTypePartRule()); }
+ iv_ruleTypePart=ruleTypePart
+ { $current=$iv_ruleTypePart.current; }
+ EOF
+;
+
+// Rule TypePart
+ruleTypePart returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getTypePartAccess().getTypeNameTypeNameParserRuleCall_0_0());
+ }
+ lv_typeName_0_0=ruleTypeName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTypePartRule());
+ }
+ set(
+ $current,
+ "typeName",
+ lv_typeName_0_0,
+ "TypeName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getTypePartAccess().getMultiplicityMultiplicityParserRuleCall_1_0());
+ }
+ lv_multiplicity_1_0=ruleMultiplicity {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTypePartRule());
+ }
+ set(
+ $current,
+ "multiplicity",
+ lv_multiplicity_1_0,
+ "Multiplicity");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleTypeName
+entryRuleTypeName returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTypeNameRule()); }
+ iv_ruleTypeName=ruleTypeName
+ { $current=$iv_ruleTypeName.current; }
+ EOF
+;
+
+// Rule TypeName
+ruleTypeName returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getTypeNameAccess().getQualifiedNameQualifiedNameParserRuleCall_0_0());
+ }
+ lv_qualifiedName_0_0=ruleQualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTypeNameRule());
+ }
+ set(
+ $current,
+ "qualifiedName",
+ lv_qualifiedName_0_0,
+ "QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ lv_any_1_0= 'any'
+ {
+ newLeafNode(lv_any_1_0, grammarAccess.getTypeNameAccess().getAnyAnyKeyword_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTypeNameRule());
+ }
+ setWithLastConsumed($current, "any", true, "any");
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleMultiplicity
+entryRuleMultiplicity returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getMultiplicityRule()); }
+ iv_ruleMultiplicity=ruleMultiplicity
+ { $current=$iv_ruleMultiplicity.current; }
+ EOF
+;
+
+// Rule Multiplicity
+ruleMultiplicity returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getMultiplicityAccess().getMultiplicityAction_0(),
+ $current);
+ }
+) otherlv_1='['
+ {
+ newLeafNode(otherlv_1, grammarAccess.getMultiplicityAccess().getLeftSquareBracketKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getMultiplicityAccess().getMultiplicityRangeMultiplicityRangeParserRuleCall_2_0());
+ }
+ lv_multiplicityRange_2_0=ruleMultiplicityRange {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getMultiplicityRule());
+ }
+ set(
+ $current,
+ "multiplicityRange",
+ lv_multiplicityRange_2_0,
+ "MultiplicityRange");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)? otherlv_3=']'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getMultiplicityAccess().getRightSquareBracketKeyword_3());
+ }
+(((
+(
+ lv_isOrdered_4_0= 'ordered'
+ {
+ newLeafNode(lv_isOrdered_4_0, grammarAccess.getMultiplicityAccess().getIsOrderedOrderedKeyword_4_0_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getMultiplicityRule());
+ }
+ setWithLastConsumed($current, "isOrdered", true, "ordered");
+ }
+
+)
+)(
+(
+ lv_isNonUnique_5_0= 'nonunique'
+ {
+ newLeafNode(lv_isNonUnique_5_0, grammarAccess.getMultiplicityAccess().getIsNonUniqueNonuniqueKeyword_4_0_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getMultiplicityRule());
+ }
+ setWithLastConsumed($current, "isNonUnique", true, "nonunique");
+ }
+
+)
+)?)
+ |((
+(
+ lv_isNonUnique_6_0= 'nonunique'
+ {
+ newLeafNode(lv_isNonUnique_6_0, grammarAccess.getMultiplicityAccess().getIsNonUniqueNonuniqueKeyword_4_1_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getMultiplicityRule());
+ }
+ setWithLastConsumed($current, "isNonUnique", true, "nonunique");
+ }
+
+)
+)(
+(
+ lv_isOrdered_7_0= 'ordered'
+ {
+ newLeafNode(lv_isOrdered_7_0, grammarAccess.getMultiplicityAccess().getIsOrderedOrderedKeyword_4_1_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getMultiplicityRule());
+ }
+ setWithLastConsumed($current, "isOrdered", true, "ordered");
+ }
+
+)
+)?)
+ |(
+(
+ lv_isSequence_8_0= 'sequence'
+ {
+ newLeafNode(lv_isSequence_8_0, grammarAccess.getMultiplicityAccess().getIsSequenceSequenceKeyword_4_2_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getMultiplicityRule());
+ }
+ setWithLastConsumed($current, "isSequence", true, "sequence");
+ }
+
+)
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleMultiplicityRange
+entryRuleMultiplicityRange returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getMultiplicityRangeRule()); }
+ iv_ruleMultiplicityRange=ruleMultiplicityRange
+ { $current=$iv_ruleMultiplicityRange.current; }
+ EOF
+;
+
+// Rule MultiplicityRange
+ruleMultiplicityRange returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+(
+ {
+ newCompositeNode(grammarAccess.getMultiplicityRangeAccess().getLowerINTEGER_LITERALParserRuleCall_0_0_0());
+ }
+ lv_lower_0_0=ruleINTEGER_LITERAL {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getMultiplicityRangeRule());
+ }
+ set(
+ $current,
+ "lower",
+ lv_lower_0_0,
+ "INTEGER_LITERAL");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_1='..'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getMultiplicityRangeAccess().getFullStopFullStopKeyword_0_1());
+ }
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getMultiplicityRangeAccess().getUpperUnlimitedNaturalLiteralParserRuleCall_1_0());
+ }
+ lv_upper_2_0=ruleUnlimitedNaturalLiteral {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getMultiplicityRangeRule());
+ }
+ set(
+ $current,
+ "upper",
+ lv_upper_2_0,
+ "UnlimitedNaturalLiteral");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleUnlimitedNaturalLiteral
+entryRuleUnlimitedNaturalLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getUnlimitedNaturalLiteralRule()); }
+ iv_ruleUnlimitedNaturalLiteral=ruleUnlimitedNaturalLiteral
+ { $current=$iv_ruleUnlimitedNaturalLiteral.current; }
+ EOF
+;
+
+// Rule UnlimitedNaturalLiteral
+ruleUnlimitedNaturalLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getUnlimitedNaturalLiteralAccess().getIntegerINTEGER_LITERALParserRuleCall_0_0());
+ }
+ lv_integer_0_0=ruleINTEGER_LITERAL {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getUnlimitedNaturalLiteralRule());
+ }
+ set(
+ $current,
+ "integer",
+ lv_integer_0_0,
+ "INTEGER_LITERAL");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ lv_star_1_0= '*'
+ {
+ newLeafNode(lv_star_1_0, grammarAccess.getUnlimitedNaturalLiteralAccess().getStarAsteriskKeyword_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getUnlimitedNaturalLiteralRule());
+ }
+ setWithLastConsumed($current, "star", true, "*");
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleOperationDeclaration
+entryRuleOperationDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getOperationDeclarationRule()); }
+ iv_ruleOperationDeclaration=ruleOperationDeclaration
+ { $current=$iv_ruleOperationDeclaration.current; }
+ EOF
+;
+
+// Rule OperationDeclaration
+ruleOperationDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_isAbstract_0_0= 'abstract'
+ {
+ newLeafNode(lv_isAbstract_0_0, grammarAccess.getOperationDeclarationAccess().getIsAbstractAbstractKeyword_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getOperationDeclarationRule());
+ }
+ setWithLastConsumed($current, "isAbstract", true, "abstract");
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getOperationDeclarationAccess().getNameNameParserRuleCall_1_0());
+ }
+ lv_name_1_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getOperationDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_1_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getOperationDeclarationAccess().getFormalParametersFormalParametersParserRuleCall_2_0());
+ }
+ lv_formalParameters_2_0=ruleFormalParameters {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getOperationDeclarationRule());
+ }
+ set(
+ $current,
+ "formalParameters",
+ lv_formalParameters_2_0,
+ "FormalParameters");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_3=':'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getOperationDeclarationAccess().getColonKeyword_3_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getOperationDeclarationAccess().getTypePartTypePartParserRuleCall_3_1_0());
+ }
+ lv_typePart_4_0=ruleTypePart {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getOperationDeclarationRule());
+ }
+ set(
+ $current,
+ "typePart",
+ lv_typePart_4_0,
+ "TypePart");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?(
+(
+ {
+ newCompositeNode(grammarAccess.getOperationDeclarationAccess().getRedefinitionClauseRedefinitionClauseParserRuleCall_4_0());
+ }
+ lv_redefinitionClause_5_0=ruleRedefinitionClause {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getOperationDeclarationRule());
+ }
+ set(
+ $current,
+ "redefinitionClause",
+ lv_redefinitionClause_5_0,
+ "RedefinitionClause");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleOperationDefinitionOrStub
+entryRuleOperationDefinitionOrStub returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getOperationDefinitionOrStubRule()); }
+ iv_ruleOperationDefinitionOrStub=ruleOperationDefinitionOrStub
+ { $current=$iv_ruleOperationDefinitionOrStub.current; }
+ EOF
+;
+
+// Rule OperationDefinitionOrStub
+ruleOperationDefinitionOrStub returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getOperationDefinitionOrStubAccess().getOperationDeclarationParserRuleCall_0());
+ }
+ this_OperationDeclaration_0=ruleOperationDeclaration
+ {
+ $current = $this_OperationDeclaration_0.current;
+ afterParserOrEnumRuleCall();
+ }
+( otherlv_1=';'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getOperationDefinitionOrStubAccess().getSemicolonKeyword_1_0());
+ }
+
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getOperationDefinitionOrStubAccess().getBlockBlockParserRuleCall_1_1_0());
+ }
+ lv_block_2_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getOperationDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "block",
+ lv_block_2_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+;
+
+
+
+
+
+// Entry rule entryRuleRedefinitionClause
+entryRuleRedefinitionClause returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getRedefinitionClauseRule()); }
+ iv_ruleRedefinitionClause=ruleRedefinitionClause
+ { $current=$iv_ruleRedefinitionClause.current; }
+ EOF
+;
+
+// Rule RedefinitionClause
+ruleRedefinitionClause returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='redefines'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getRedefinitionClauseAccess().getRedefinesKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getRedefinitionClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_1_0());
+ }
+ lv_qualifiedNameList_1_0=ruleQualifiedNameList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getRedefinitionClauseRule());
+ }
+ set(
+ $current,
+ "qualifiedNameList",
+ lv_qualifiedNameList_1_0,
+ "QualifiedNameList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleReceptionDefinition
+entryRuleReceptionDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getReceptionDefinitionRule()); }
+ iv_ruleReceptionDefinition=ruleReceptionDefinition
+ { $current=$iv_ruleReceptionDefinition.current; }
+ EOF
+;
+
+// Rule ReceptionDefinition
+ruleReceptionDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='receive'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getReceptionDefinitionAccess().getReceiveKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getReceptionDefinitionAccess().getReceptionNameQualifiedNameParserRuleCall_1_0());
+ }
+ lv_receptionName_1_0=ruleQualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getReceptionDefinitionRule());
+ }
+ set(
+ $current,
+ "receptionName",
+ lv_receptionName_1_0,
+ "QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_2=';'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getReceptionDefinitionAccess().getSemicolonKeyword_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleSignalReceptionDeclaration
+entryRuleSignalReceptionDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSignalReceptionDeclarationRule()); }
+ iv_ruleSignalReceptionDeclaration=ruleSignalReceptionDeclaration
+ { $current=$iv_ruleSignalReceptionDeclaration.current; }
+ EOF
+;
+
+// Rule SignalReceptionDeclaration
+ruleSignalReceptionDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='receive'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getSignalReceptionDeclarationAccess().getReceiveKeyword_0());
+ }
+ otherlv_1='signal'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getSignalReceptionDeclarationAccess().getSignalKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getSignalReceptionDeclarationAccess().getSignalNameNameParserRuleCall_2_0());
+ }
+ lv_signalName_2_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSignalReceptionDeclarationRule());
+ }
+ set(
+ $current,
+ "signalName",
+ lv_signalName_2_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getSignalReceptionDeclarationAccess().getSpecializationClauseSpecializationClauseParserRuleCall_3_0());
+ }
+ lv_specializationClause_3_0=ruleSpecializationClause {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSignalReceptionDeclarationRule());
+ }
+ set(
+ $current,
+ "specializationClause",
+ lv_specializationClause_3_0,
+ "SpecializationClause");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleSignalReceptionDefinitionOrStub
+entryRuleSignalReceptionDefinitionOrStub returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSignalReceptionDefinitionOrStubRule()); }
+ iv_ruleSignalReceptionDefinitionOrStub=ruleSignalReceptionDefinitionOrStub
+ { $current=$iv_ruleSignalReceptionDefinitionOrStub.current; }
+ EOF
+;
+
+// Rule SignalReceptionDefinitionOrStub
+ruleSignalReceptionDefinitionOrStub returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getSignalReceptionDefinitionOrStubAccess().getSignalReceptionOrDeclarationSignalReceptionDeclarationParserRuleCall_0_0());
+ }
+ lv_signalReceptionOrDeclaration_0_0=ruleSignalReceptionDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSignalReceptionDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "signalReceptionOrDeclaration",
+ lv_signalReceptionOrDeclaration_0_0,
+ "SignalReceptionDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=';'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getSignalReceptionDefinitionOrStubAccess().getSemicolonKeyword_1_0());
+ }
+
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getSignalReceptionDefinitionOrStubAccess().getStructuredBodyStructuredBodyParserRuleCall_1_1_0());
+ }
+ lv_structuredBody_2_0=ruleStructuredBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSignalReceptionDefinitionOrStubRule());
+ }
+ set(
+ $current,
+ "structuredBody",
+ lv_structuredBody_2_0,
+ "StructuredBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+;
+
+
+
+
+
+// Entry rule entryRuleName
+entryRuleName returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNameRule()); }
+ iv_ruleName=ruleName
+ { $current=$iv_ruleName.current; }
+ EOF
+;
+
+// Rule Name
+ruleName returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ lv_id_0_0=RULE_ID
+ {
+ newLeafNode(lv_id_0_0, grammarAccess.getNameAccess().getIdIDTerminalRuleCall_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getNameRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "id",
+ lv_id_0_0,
+ "ID");
+ }
+
+)
+)
+;
+
+
+
+
+
+// Entry rule entryRuleQualifiedName
+entryRuleQualifiedName returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getQualifiedNameRule()); }
+ iv_ruleQualifiedName=ruleQualifiedName
+ { $current=$iv_ruleQualifiedName.current; }
+ EOF
+;
+
+// Rule QualifiedName
+ruleQualifiedName returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getQualifiedNameAccess().getUnqualifiedUnqualifiedNameParserRuleCall_0_0());
+ }
+ lv_unqualified_0_0=ruleUnqualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getQualifiedNameRule());
+ }
+ set(
+ $current,
+ "unqualified",
+ lv_unqualified_0_0,
+ "UnqualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getQualifiedNameAccess().getNameCompletionColonQualifiedNameCompletionParserRuleCall_1_0());
+ }
+ lv_nameCompletion_1_0=ruleColonQualifiedNameCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getQualifiedNameRule());
+ }
+ set(
+ $current,
+ "nameCompletion",
+ lv_nameCompletion_1_0,
+ "ColonQualifiedNameCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleColonQualifiedNameCompletion
+entryRuleColonQualifiedNameCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getColonQualifiedNameCompletionRule()); }
+ iv_ruleColonQualifiedNameCompletion=ruleColonQualifiedNameCompletion
+ { $current=$iv_ruleColonQualifiedNameCompletion.current; }
+ EOF
+;
+
+// Rule ColonQualifiedNameCompletion
+ruleColonQualifiedNameCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='::'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getColonQualifiedNameCompletionAccess().getColonColonKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getColonQualifiedNameCompletionAccess().getNamedBindingsNameBindingParserRuleCall_1_0());
+ }
+ lv_namedBindings_1_0=ruleNameBinding {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getColonQualifiedNameCompletionRule());
+ }
+ add(
+ $current,
+ "namedBindings",
+ lv_namedBindings_1_0,
+ "NameBinding");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))+
+;
+
+
+
+
+
+// Entry rule entryRuleUnqualifiedName
+entryRuleUnqualifiedName returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getUnqualifiedNameRule()); }
+ iv_ruleUnqualifiedName=ruleUnqualifiedName
+ { $current=$iv_ruleUnqualifiedName.current; }
+ EOF
+;
+
+// Rule UnqualifiedName
+ruleUnqualifiedName returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+
+ {
+ newCompositeNode(grammarAccess.getUnqualifiedNameAccess().getNameBindingParserRuleCall());
+ }
+ this_NameBinding_0=ruleNameBinding
+ {
+ $current = $this_NameBinding_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+;
+
+
+
+
+
+// Entry rule entryRuleNameBinding
+entryRuleNameBinding returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNameBindingRule()); }
+ iv_ruleNameBinding=ruleNameBinding
+ { $current=$iv_ruleNameBinding.current; }
+ EOF
+;
+
+// Rule NameBinding
+ruleNameBinding returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getNameBindingAccess().getNameNameParserRuleCall_0_0());
+ }
+ lv_name_0_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNameBindingRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_0_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getNameBindingAccess().getTemplateBindingTemplateBindingParserRuleCall_1_0());
+ }
+ lv_templateBinding_1_0=ruleTemplateBinding {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNameBindingRule());
+ }
+ set(
+ $current,
+ "templateBinding",
+ lv_templateBinding_1_0,
+ "TemplateBinding");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleQualifiedNameWithoutBinding
+entryRuleQualifiedNameWithoutBinding returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getQualifiedNameWithoutBindingRule()); }
+ iv_ruleQualifiedNameWithoutBinding=ruleQualifiedNameWithoutBinding
+ { $current=$iv_ruleQualifiedNameWithoutBinding.current; }
+ EOF
+;
+
+// Rule QualifiedNameWithoutBinding
+ruleQualifiedNameWithoutBinding returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getQualifiedNameWithoutBindingAccess().getUnqualifiedNameParserRuleCall_0_0());
+ }
+ lv_unqualified_0_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getQualifiedNameWithoutBindingRule());
+ }
+ set(
+ $current,
+ "unqualified",
+ lv_unqualified_0_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getQualifiedNameWithoutBindingAccess().getNameCompletionColonQualifiedNameCompletionWithoutBindingParserRuleCall_1_0());
+ }
+ lv_nameCompletion_1_0=ruleColonQualifiedNameCompletionWithoutBinding {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getQualifiedNameWithoutBindingRule());
+ }
+ set(
+ $current,
+ "nameCompletion",
+ lv_nameCompletion_1_0,
+ "ColonQualifiedNameCompletionWithoutBinding");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleColonQualifiedNameCompletionWithoutBinding
+entryRuleColonQualifiedNameCompletionWithoutBinding returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getColonQualifiedNameCompletionWithoutBindingRule()); }
+ iv_ruleColonQualifiedNameCompletionWithoutBinding=ruleColonQualifiedNameCompletionWithoutBinding
+ { $current=$iv_ruleColonQualifiedNameCompletionWithoutBinding.current; }
+ EOF
+;
+
+// Rule ColonQualifiedNameCompletionWithoutBinding
+ruleColonQualifiedNameCompletionWithoutBinding returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='::'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getColonQualifiedNameCompletionWithoutBindingAccess().getColonColonKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getColonQualifiedNameCompletionWithoutBindingAccess().getNamesNameParserRuleCall_1_0());
+ }
+ lv_names_1_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getColonQualifiedNameCompletionWithoutBindingRule());
+ }
+ add(
+ $current,
+ "names",
+ lv_names_1_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))+
+;
+
+
+
+
+
+// Entry rule entryRuleTemplateBinding
+entryRuleTemplateBinding returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTemplateBindingRule()); }
+ iv_ruleTemplateBinding=ruleTemplateBinding
+ { $current=$iv_ruleTemplateBinding.current; }
+ EOF
+;
+
+// Rule TemplateBinding
+ruleTemplateBinding returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='<'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getTemplateBindingAccess().getLessThanSignKeyword_0());
+ }
+(
+ {
+ newCompositeNode(grammarAccess.getTemplateBindingAccess().getNamedTemplateBindingParserRuleCall_1_0());
+ }
+ this_NamedTemplateBinding_1=ruleNamedTemplateBinding
+ {
+ $current = $this_NamedTemplateBinding_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getTemplateBindingAccess().getPositionalTemplateBindingParserRuleCall_1_1());
+ }
+ this_PositionalTemplateBinding_2=rulePositionalTemplateBinding
+ {
+ $current = $this_PositionalTemplateBinding_2.current;
+ afterParserOrEnumRuleCall();
+ }
+) otherlv_3='>'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getTemplateBindingAccess().getGreaterThanSignKeyword_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRulePositionalTemplateBinding
+entryRulePositionalTemplateBinding returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPositionalTemplateBindingRule()); }
+ iv_rulePositionalTemplateBinding=rulePositionalTemplateBinding
+ { $current=$iv_rulePositionalTemplateBinding.current; }
+ EOF
+;
+
+// Rule PositionalTemplateBinding
+rulePositionalTemplateBinding returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getPositionalTemplateBindingAccess().getQualifiedNameQualifiedNameParserRuleCall_0_0());
+ }
+ lv_qualifiedName_0_0=ruleQualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPositionalTemplateBindingRule());
+ }
+ add(
+ $current,
+ "qualifiedName",
+ lv_qualifiedName_0_0,
+ "QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=','
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPositionalTemplateBindingAccess().getCommaKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPositionalTemplateBindingAccess().getQualifiedNameQualifiedNameParserRuleCall_1_1_0());
+ }
+ lv_qualifiedName_2_0=ruleQualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPositionalTemplateBindingRule());
+ }
+ add(
+ $current,
+ "qualifiedName",
+ lv_qualifiedName_2_0,
+ "QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleNamedTemplateBinding
+entryRuleNamedTemplateBinding returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNamedTemplateBindingRule()); }
+ iv_ruleNamedTemplateBinding=ruleNamedTemplateBinding
+ { $current=$iv_ruleNamedTemplateBinding.current; }
+ EOF
+;
+
+// Rule NamedTemplateBinding
+ruleNamedTemplateBinding returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getNamedTemplateBindingAccess().getTemplateParameterSubstitutionTemplateParameterSubstitutionParserRuleCall_0_0());
+ }
+ lv_templateParameterSubstitution_0_0=ruleTemplateParameterSubstitution {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNamedTemplateBindingRule());
+ }
+ add(
+ $current,
+ "templateParameterSubstitution",
+ lv_templateParameterSubstitution_0_0,
+ "TemplateParameterSubstitution");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=','
+ {
+ newLeafNode(otherlv_1, grammarAccess.getNamedTemplateBindingAccess().getCommaKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getNamedTemplateBindingAccess().getTemplateParameterSubstitutionTemplateParameterSubstitutionParserRuleCall_1_1_0());
+ }
+ lv_templateParameterSubstitution_2_0=ruleTemplateParameterSubstitution {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNamedTemplateBindingRule());
+ }
+ add(
+ $current,
+ "templateParameterSubstitution",
+ lv_templateParameterSubstitution_2_0,
+ "TemplateParameterSubstitution");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleTemplateParameterSubstitution
+entryRuleTemplateParameterSubstitution returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTemplateParameterSubstitutionRule()); }
+ iv_ruleTemplateParameterSubstitution=ruleTemplateParameterSubstitution
+ { $current=$iv_ruleTemplateParameterSubstitution.current; }
+ EOF
+;
+
+// Rule TemplateParameterSubstitution
+ruleTemplateParameterSubstitution returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getTemplateParameterSubstitutionAccess().getNameNameParserRuleCall_0_0());
+ }
+ lv_name_0_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTemplateParameterSubstitutionRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_0_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_1='=>'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTemplateParameterSubstitutionAccess().getEqualsSignGreaterThanSignKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTemplateParameterSubstitutionAccess().getQualifiedNameQualifiedNameParserRuleCall_2_0());
+ }
+ lv_qualifiedName_2_0=ruleQualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTemplateParameterSubstitutionRule());
+ }
+ set(
+ $current,
+ "qualifiedName",
+ lv_qualifiedName_2_0,
+ "QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleExpression
+entryRuleExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getExpressionRule()); }
+ iv_ruleExpression=ruleExpression
+ { $current=$iv_ruleExpression.current; }
+ EOF
+;
+
+// Rule Expression
+ruleExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getExpressionAccess().getUnaryExpressionUnaryExpressionParserRuleCall_0_0());
+ }
+ lv_unaryExpression_0_0=ruleUnaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExpressionRule());
+ }
+ set(
+ $current,
+ "unaryExpression",
+ lv_unaryExpression_0_0,
+ "UnaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getExpressionAccess().getExpressionCompletionExpressionCompletionParserRuleCall_1_0());
+ }
+ lv_expressionCompletion_1_0=ruleExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExpressionRule());
+ }
+ set(
+ $current,
+ "expressionCompletion",
+ lv_expressionCompletion_1_0,
+ "ExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleNonNameExpression
+entryRuleNonNameExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNonNameExpressionRule()); }
+ iv_ruleNonNameExpression=ruleNonNameExpression
+ { $current=$iv_ruleNonNameExpression.current; }
+ EOF
+;
+
+// Rule NonNameExpression
+ruleNonNameExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getNonNameExpressionAccess().getNonNameUnaryExpressionNonNameUnaryExpressionParserRuleCall_0_0());
+ }
+ lv_nonNameUnaryExpression_0_0=ruleNonNameUnaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNonNameExpressionRule());
+ }
+ set(
+ $current,
+ "nonNameUnaryExpression",
+ lv_nonNameUnaryExpression_0_0,
+ "NonNameUnaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getNonNameExpressionAccess().getExpressionCompletionExpressionCompletionParserRuleCall_1_0());
+ }
+ lv_expressionCompletion_1_0=ruleExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNonNameExpressionRule());
+ }
+ set(
+ $current,
+ "expressionCompletion",
+ lv_expressionCompletion_1_0,
+ "ExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleNameToExpressionCompletion
+entryRuleNameToExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNameToExpressionCompletionRule()); }
+ iv_ruleNameToExpressionCompletion=ruleNameToExpressionCompletion
+ { $current=$iv_ruleNameToExpressionCompletion.current; }
+ EOF
+;
+
+// Rule NameToExpressionCompletion
+ruleNameToExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getNameToExpressionCompletionAccess().getNameToPrimaryNameToPrimaryExpressionParserRuleCall_0_0());
+ }
+ lv_nameToPrimary_0_0=ruleNameToPrimaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNameToExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "nameToPrimary",
+ lv_nameToPrimary_0_0,
+ "NameToPrimaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getNameToExpressionCompletionAccess().getPrimaryToExpressionCompletionPrimaryToExpressionCompletionParserRuleCall_1_0());
+ }
+ lv_primaryToExpressionCompletion_1_0=rulePrimaryToExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNameToExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "primaryToExpressionCompletion",
+ lv_primaryToExpressionCompletion_1_0,
+ "PrimaryToExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRulePrimaryToExpressionCompletion
+entryRulePrimaryToExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPrimaryToExpressionCompletionRule()); }
+ iv_rulePrimaryToExpressionCompletion=rulePrimaryToExpressionCompletion
+ { $current=$iv_rulePrimaryToExpressionCompletion.current; }
+ EOF
+;
+
+// Rule PrimaryToExpressionCompletion
+rulePrimaryToExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryToExpressionCompletionAccess().getPostFixExpressionCompletionPostfixExpressionCompletionParserRuleCall_0_0());
+ }
+ lv_postFixExpressionCompletion_0_0=rulePostfixExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryToExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "postFixExpressionCompletion",
+ lv_postFixExpressionCompletion_0_0,
+ "PostfixExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryToExpressionCompletionAccess().getExpressionCompletionExpressionCompletionParserRuleCall_1_0());
+ }
+ lv_expressionCompletion_1_0=ruleExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryToExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "expressionCompletion",
+ lv_expressionCompletion_1_0,
+ "ExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleExpressionCompletion
+entryRuleExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getExpressionCompletionRule()); }
+ iv_ruleExpressionCompletion=ruleExpressionCompletion
+ { $current=$iv_ruleExpressionCompletion.current; }
+ EOF
+;
+
+// Rule ExpressionCompletion
+ruleExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getExpressionCompletionAccess().getAssignmentExpressionCompletionParserRuleCall_0());
+ }
+ this_AssignmentExpressionCompletion_0=ruleAssignmentExpressionCompletion
+ {
+ $current = $this_AssignmentExpressionCompletion_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getExpressionCompletionAccess().getConditionalExpressionCompletionParserRuleCall_1());
+ }
+ this_ConditionalExpressionCompletion_1=ruleConditionalExpressionCompletion
+ {
+ $current = $this_ConditionalExpressionCompletion_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRulePrimaryExpression
+entryRulePrimaryExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPrimaryExpressionRule()); }
+ iv_rulePrimaryExpression=rulePrimaryExpression
+ { $current=$iv_rulePrimaryExpression.current; }
+ EOF
+;
+
+// Rule PrimaryExpression
+rulePrimaryExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getNameOrPrimaryExpressionNameOrPrimaryExpressionParserRuleCall_0_0_0());
+ }
+ lv_nameOrPrimaryExpression_0_0=ruleNameOrPrimaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "nameOrPrimaryExpression",
+ lv_nameOrPrimaryExpression_0_0,
+ "NameOrPrimaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBaseExpressionBaseExpressionParserRuleCall_0_1_0());
+ }
+ lv_baseExpression_1_0=ruleBaseExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "baseExpression",
+ lv_baseExpression_1_0,
+ "BaseExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getParenthesizedExpressionParenthesizedExpressionParserRuleCall_0_2_0());
+ }
+ lv_parenthesizedExpression_2_0=ruleParenthesizedExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "parenthesizedExpression",
+ lv_parenthesizedExpression_2_0,
+ "ParenthesizedExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getPrimaryExpressionCompletionPrimaryExpressionCompletionParserRuleCall_1_0());
+ }
+ lv_primaryExpressionCompletion_3_0=rulePrimaryExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "primaryExpressionCompletion",
+ lv_primaryExpressionCompletion_3_0,
+ "PrimaryExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleBaseExpression
+entryRuleBaseExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getBaseExpressionRule()); }
+ iv_ruleBaseExpression=ruleBaseExpression
+ { $current=$iv_ruleBaseExpression.current; }
+ EOF
+;
+
+// Rule BaseExpression
+ruleBaseExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getBaseExpressionAccess().getLiteralExpressionParserRuleCall_0());
+ }
+ this_LiteralExpression_0=ruleLiteralExpression
+ {
+ $current = $this_LiteralExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getBaseExpressionAccess().getThisExpressionParserRuleCall_1());
+ }
+ this_ThisExpression_1=ruleThisExpression
+ {
+ $current = $this_ThisExpression_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getBaseExpressionAccess().getSuperInvocationExpressionParserRuleCall_2());
+ }
+ this_SuperInvocationExpression_2=ruleSuperInvocationExpression
+ {
+ $current = $this_SuperInvocationExpression_2.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getBaseExpressionAccess().getInstanceCreationOrSequenceConstructionExpressionParserRuleCall_3());
+ }
+ this_InstanceCreationOrSequenceConstructionExpression_3=ruleInstanceCreationOrSequenceConstructionExpression
+ {
+ $current = $this_InstanceCreationOrSequenceConstructionExpression_3.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getBaseExpressionAccess().getSequenceAnyExpressionParserRuleCall_4());
+ }
+ this_SequenceAnyExpression_4=ruleSequenceAnyExpression
+ {
+ $current = $this_SequenceAnyExpression_4.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleNameToPrimaryExpression
+entryRuleNameToPrimaryExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNameToPrimaryExpressionRule()); }
+ iv_ruleNameToPrimaryExpression=ruleNameToPrimaryExpression
+ { $current=$iv_ruleNameToPrimaryExpression.current; }
+ EOF
+;
+
+// Rule NameToPrimaryExpression
+ruleNameToPrimaryExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(( otherlv_0='.'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getNameToPrimaryExpressionAccess().getFullStopKeyword_0_0());
+ }
+((
+(
+ {
+ newCompositeNode(grammarAccess.getNameToPrimaryExpressionAccess().getLinkOperationCompletionLinkOperationCompletionParserRuleCall_0_1_0_0());
+ }
+ lv_linkOperationCompletion_1_0=ruleLinkOperationCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNameToPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "linkOperationCompletion",
+ lv_linkOperationCompletion_1_0,
+ "LinkOperationCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getNameToPrimaryExpressionAccess().getClassExtentExpressionCompletionClassExtentExpressionCompletionParserRuleCall_0_1_1_0());
+ }
+ lv_classExtentExpressionCompletion_2_0=ruleClassExtentExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNameToPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "classExtentExpressionCompletion",
+ lv_classExtentExpressionCompletion_2_0,
+ "ClassExtentExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getNameToPrimaryExpressionAccess().getSequenceConstructionCompletionSequenceConstructionExpressionCompletionParserRuleCall_1_0());
+ }
+ lv_sequenceConstructionCompletion_3_0=ruleSequenceConstructionExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNameToPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "sequenceConstructionCompletion",
+ lv_sequenceConstructionCompletion_3_0,
+ "SequenceConstructionExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getNameToPrimaryExpressionAccess().getBehaviorInvocationBehaviorInvocationParserRuleCall_2_0());
+ }
+ lv_behaviorInvocation_4_0=ruleBehaviorInvocation {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNameToPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "behaviorInvocation",
+ lv_behaviorInvocation_4_0,
+ "BehaviorInvocation");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRulePrimaryExpressionCompletion
+entryRulePrimaryExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPrimaryExpressionCompletionRule()); }
+ iv_rulePrimaryExpressionCompletion=rulePrimaryExpressionCompletion
+ { $current=$iv_rulePrimaryExpressionCompletion.current; }
+ EOF
+;
+
+// Rule PrimaryExpressionCompletion
+rulePrimaryExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionCompletionAccess().getContentFeature_Or_SequenceOperationOrReductionOrExpansion_Or_IndexParserRuleCall_0());
+ }
+ lv_content_0_0=ruleFeature_Or_SequenceOperationOrReductionOrExpansion_Or_Index {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionCompletionRule());
+ }
+ add(
+ $current,
+ "content",
+ lv_content_0_0,
+ "Feature_Or_SequenceOperationOrReductionOrExpansion_Or_Index");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)+
+;
+
+
+
+
+
+// Entry rule entryRuleFeature_Or_SequenceOperationOrReductionOrExpansion_Or_Index
+entryRuleFeature_Or_SequenceOperationOrReductionOrExpansion_Or_Index returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getFeature_Or_SequenceOperationOrReductionOrExpansion_Or_IndexRule()); }
+ iv_ruleFeature_Or_SequenceOperationOrReductionOrExpansion_Or_Index=ruleFeature_Or_SequenceOperationOrReductionOrExpansion_Or_Index
+ { $current=$iv_ruleFeature_Or_SequenceOperationOrReductionOrExpansion_Or_Index.current; }
+ EOF
+;
+
+// Rule Feature_Or_SequenceOperationOrReductionOrExpansion_Or_Index
+ruleFeature_Or_SequenceOperationOrReductionOrExpansion_Or_Index returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+(
+ {
+ newCompositeNode(grammarAccess.getFeature_Or_SequenceOperationOrReductionOrExpansion_Or_IndexAccess().getFeatureFeatureParserRuleCall_0_0_0());
+ }
+ lv_feature_0_0=ruleFeature {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFeature_Or_SequenceOperationOrReductionOrExpansion_Or_IndexRule());
+ }
+ set(
+ $current,
+ "feature",
+ lv_feature_0_0,
+ "Feature");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getFeature_Or_SequenceOperationOrReductionOrExpansion_Or_IndexAccess().getFeatureInvocationFeatureInvocationParserRuleCall_0_1_0());
+ }
+ lv_featureInvocation_1_0=ruleFeatureInvocation {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFeature_Or_SequenceOperationOrReductionOrExpansion_Or_IndexRule());
+ }
+ set(
+ $current,
+ "featureInvocation",
+ lv_featureInvocation_1_0,
+ "FeatureInvocation");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getFeature_Or_SequenceOperationOrReductionOrExpansion_Or_IndexAccess().getSequenceOperationOrReductionOrExpansionSequenceOperationOrReductionOrExpansionParserRuleCall_1_0());
+ }
+ lv_sequenceOperationOrReductionOrExpansion_2_0=ruleSequenceOperationOrReductionOrExpansion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFeature_Or_SequenceOperationOrReductionOrExpansion_Or_IndexRule());
+ }
+ set(
+ $current,
+ "sequenceOperationOrReductionOrExpansion",
+ lv_sequenceOperationOrReductionOrExpansion_2_0,
+ "SequenceOperationOrReductionOrExpansion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getFeature_Or_SequenceOperationOrReductionOrExpansion_Or_IndexAccess().getIndexIndexParserRuleCall_2_0());
+ }
+ lv_index_3_0=ruleIndex {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFeature_Or_SequenceOperationOrReductionOrExpansion_Or_IndexRule());
+ }
+ set(
+ $current,
+ "index",
+ lv_index_3_0,
+ "Index");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleLiteralExpression
+entryRuleLiteralExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getLiteralExpressionRule()); }
+ iv_ruleLiteralExpression=ruleLiteralExpression
+ { $current=$iv_ruleLiteralExpression.current; }
+ EOF
+;
+
+// Rule LiteralExpression
+ruleLiteralExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ {
+ newCompositeNode(grammarAccess.getLiteralExpressionAccess().getExpressionPRIMITIVE_LITERALParserRuleCall_0());
+ }
+ lv_expression_0_0=rulePRIMITIVE_LITERAL {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLiteralExpressionRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_0_0,
+ "PRIMITIVE_LITERAL");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+;
+
+
+
+
+
+// Entry rule entryRuleNameOrPrimaryExpression
+entryRuleNameOrPrimaryExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNameOrPrimaryExpressionRule()); }
+ iv_ruleNameOrPrimaryExpression=ruleNameOrPrimaryExpression
+ { $current=$iv_ruleNameOrPrimaryExpression.current; }
+ EOF
+;
+
+// Rule NameOrPrimaryExpression
+ruleNameOrPrimaryExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getNameOrPrimaryExpressionAccess().getPotentiallyAmbiguousQualifiedNameQualifiedNameWithoutBindingParserRuleCall_0_0());
+ }
+ lv_potentiallyAmbiguousQualifiedName_0_0=ruleQualifiedNameWithoutBinding {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNameOrPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "potentiallyAmbiguousQualifiedName",
+ lv_potentiallyAmbiguousQualifiedName_0_0,
+ "QualifiedNameWithoutBinding");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getNameOrPrimaryExpressionAccess().getNameToPrimaryExpressionNameToPrimaryExpressionParserRuleCall_1_0());
+ }
+ lv_nameToPrimaryExpression_1_0=ruleNameToPrimaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNameOrPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "nameToPrimaryExpression",
+ lv_nameToPrimaryExpression_1_0,
+ "NameToPrimaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleThisExpression
+entryRuleThisExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getThisExpressionRule()); }
+ iv_ruleThisExpression=ruleThisExpression
+ { $current=$iv_ruleThisExpression.current; }
+ EOF
+;
+
+// Rule ThisExpression
+ruleThisExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getThisExpressionAccess().getThisExpressionAction_0(),
+ $current);
+ }
+) otherlv_1='this'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getThisExpressionAccess().getThisKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getThisExpressionAccess().getTupleTupleParserRuleCall_2_0());
+ }
+ lv_tuple_2_0=ruleTuple {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getThisExpressionRule());
+ }
+ set(
+ $current,
+ "tuple",
+ lv_tuple_2_0,
+ "Tuple");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleParenthesizedExpression
+entryRuleParenthesizedExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getParenthesizedExpressionRule()); }
+ iv_ruleParenthesizedExpression=ruleParenthesizedExpression
+ { $current=$iv_ruleParenthesizedExpression.current; }
+ EOF
+;
+
+// Rule ParenthesizedExpression
+ruleParenthesizedExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='('
+ {
+ newLeafNode(otherlv_0, grammarAccess.getParenthesizedExpressionAccess().getLeftParenthesisKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getParenthesizedExpressionAccess().getExpressionExpressionParserRuleCall_1_0());
+ }
+ lv_expression_1_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getParenthesizedExpressionRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_2=')'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getParenthesizedExpressionAccess().getRightParenthesisKeyword_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleFeature
+entryRuleFeature returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getFeatureRule()); }
+ iv_ruleFeature=ruleFeature
+ { $current=$iv_ruleFeature.current; }
+ EOF
+;
+
+// Rule Feature
+ruleFeature returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='.'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getFeatureAccess().getFullStopKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getFeatureAccess().getNameNameParserRuleCall_1_0());
+ }
+ lv_name_1_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFeatureRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_1_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleTuple
+entryRuleTuple returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTupleRule()); }
+ iv_ruleTuple=ruleTuple
+ { $current=$iv_ruleTuple.current; }
+ EOF
+;
+
+// Rule Tuple
+ruleTuple returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTupleAccess().getTupleAction_0(),
+ $current);
+ }
+) otherlv_1='('
+ {
+ newLeafNode(otherlv_1, grammarAccess.getTupleAccess().getLeftParenthesisKeyword_1());
+ }
+(((
+(
+ruleName
+)
+)=>
+(
+ {
+ newCompositeNode(grammarAccess.getTupleAccess().getNamedTupleExpressionListNamedTupleExpressionListParserRuleCall_2_0_0());
+ }
+ lv_namedTupleExpressionList_2_0=ruleNamedTupleExpressionList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTupleRule());
+ }
+ set(
+ $current,
+ "namedTupleExpressionList",
+ lv_namedTupleExpressionList_2_0,
+ "NamedTupleExpressionList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getTupleAccess().getPositionalTupleExpressionListPositionalTupleExpressionListParserRuleCall_2_1_0());
+ }
+ lv_positionalTupleExpressionList_3_0=rulePositionalTupleExpressionList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTupleRule());
+ }
+ set(
+ $current,
+ "positionalTupleExpressionList",
+ lv_positionalTupleExpressionList_3_0,
+ "PositionalTupleExpressionList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))? otherlv_4=')'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getTupleAccess().getRightParenthesisKeyword_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRulePositionalTupleExpressionList
+entryRulePositionalTupleExpressionList returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPositionalTupleExpressionListRule()); }
+ iv_rulePositionalTupleExpressionList=rulePositionalTupleExpressionList
+ { $current=$iv_rulePositionalTupleExpressionList.current; }
+ EOF
+;
+
+// Rule PositionalTupleExpressionList
+rulePositionalTupleExpressionList returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getPositionalTupleExpressionListAccess().getExpressionExpressionParserRuleCall_0_0());
+ }
+ lv_expression_0_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPositionalTupleExpressionListRule());
+ }
+ add(
+ $current,
+ "expression",
+ lv_expression_0_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=','
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPositionalTupleExpressionListAccess().getCommaKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPositionalTupleExpressionListAccess().getExpressionExpressionParserRuleCall_1_1_0());
+ }
+ lv_expression_2_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPositionalTupleExpressionListRule());
+ }
+ add(
+ $current,
+ "expression",
+ lv_expression_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRulePositionalTupleExpressionListCompletion
+entryRulePositionalTupleExpressionListCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPositionalTupleExpressionListCompletionRule()); }
+ iv_rulePositionalTupleExpressionListCompletion=rulePositionalTupleExpressionListCompletion
+ { $current=$iv_rulePositionalTupleExpressionListCompletion.current; }
+ EOF
+;
+
+// Rule PositionalTupleExpressionListCompletion
+rulePositionalTupleExpressionListCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPositionalTupleExpressionListCompletionAccess().getPositionalTupleExpressionListCompletionAction_0(),
+ $current);
+ }
+)( otherlv_1=','
+ {
+ newLeafNode(otherlv_1, grammarAccess.getPositionalTupleExpressionListCompletionAccess().getCommaKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPositionalTupleExpressionListCompletionAccess().getExpressionExpressionParserRuleCall_1_1_0());
+ }
+ lv_expression_2_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPositionalTupleExpressionListCompletionRule());
+ }
+ add(
+ $current,
+ "expression",
+ lv_expression_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleNamedTupleExpressionList
+entryRuleNamedTupleExpressionList returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNamedTupleExpressionListRule()); }
+ iv_ruleNamedTupleExpressionList=ruleNamedTupleExpressionList
+ { $current=$iv_ruleNamedTupleExpressionList.current; }
+ EOF
+;
+
+// Rule NamedTupleExpressionList
+ruleNamedTupleExpressionList returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+(
+ruleName
+)
+)=>
+(
+ {
+ newCompositeNode(grammarAccess.getNamedTupleExpressionListAccess().getNamedExpressionNamedExpressionParserRuleCall_0_0());
+ }
+ lv_namedExpression_0_0=ruleNamedExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNamedTupleExpressionListRule());
+ }
+ add(
+ $current,
+ "namedExpression",
+ lv_namedExpression_0_0,
+ "NamedExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=','
+ {
+ newLeafNode(otherlv_1, grammarAccess.getNamedTupleExpressionListAccess().getCommaKeyword_1_0());
+ }
+((
+(
+ruleName
+)
+)=>
+(
+ {
+ newCompositeNode(grammarAccess.getNamedTupleExpressionListAccess().getNamedExpressionNamedExpressionParserRuleCall_1_1_0());
+ }
+ lv_namedExpression_2_0=ruleNamedExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNamedTupleExpressionListRule());
+ }
+ add(
+ $current,
+ "namedExpression",
+ lv_namedExpression_2_0,
+ "NamedExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleNamedExpression
+entryRuleNamedExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNamedExpressionRule()); }
+ iv_ruleNamedExpression=ruleNamedExpression
+ { $current=$iv_ruleNamedExpression.current; }
+ EOF
+;
+
+// Rule NamedExpression
+ruleNamedExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+(
+ruleName
+)
+)=>
+(
+ {
+ newCompositeNode(grammarAccess.getNamedExpressionAccess().getNameNameParserRuleCall_0_0());
+ }
+ lv_name_0_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNamedExpressionRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_0_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_1='=>'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getNamedExpressionAccess().getEqualsSignGreaterThanSignKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getNamedExpressionAccess().getExpressionExpressionParserRuleCall_2_0());
+ }
+ lv_expression_2_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNamedExpressionRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleBehaviorInvocation
+entryRuleBehaviorInvocation returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getBehaviorInvocationRule()); }
+ iv_ruleBehaviorInvocation=ruleBehaviorInvocation
+ { $current=$iv_ruleBehaviorInvocation.current; }
+ EOF
+;
+
+// Rule BehaviorInvocation
+ruleBehaviorInvocation returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ {
+ newCompositeNode(grammarAccess.getBehaviorInvocationAccess().getTupleTupleParserRuleCall_0());
+ }
+ lv_tuple_0_0=ruleTuple {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getBehaviorInvocationRule());
+ }
+ set(
+ $current,
+ "tuple",
+ lv_tuple_0_0,
+ "Tuple");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+;
+
+
+
+
+
+// Entry rule entryRuleFeatureInvocation
+entryRuleFeatureInvocation returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getFeatureInvocationRule()); }
+ iv_ruleFeatureInvocation=ruleFeatureInvocation
+ { $current=$iv_ruleFeatureInvocation.current; }
+ EOF
+;
+
+// Rule FeatureInvocation
+ruleFeatureInvocation returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ {
+ newCompositeNode(grammarAccess.getFeatureInvocationAccess().getTupleTupleParserRuleCall_0());
+ }
+ lv_tuple_0_0=ruleTuple {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFeatureInvocationRule());
+ }
+ set(
+ $current,
+ "tuple",
+ lv_tuple_0_0,
+ "Tuple");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+;
+
+
+
+
+
+// Entry rule entryRuleSuperInvocationExpression
+entryRuleSuperInvocationExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSuperInvocationExpressionRule()); }
+ iv_ruleSuperInvocationExpression=ruleSuperInvocationExpression
+ { $current=$iv_ruleSuperInvocationExpression.current; }
+ EOF
+;
+
+// Rule SuperInvocationExpression
+ruleSuperInvocationExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='super'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getSuperInvocationExpressionAccess().getSuperKeyword_0());
+ }
+( otherlv_1='.'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getSuperInvocationExpressionAccess().getFullStopKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getSuperInvocationExpressionAccess().getQualifiedNameQualifiedNameParserRuleCall_1_1_0());
+ }
+ lv_qualifiedName_2_0=ruleQualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSuperInvocationExpressionRule());
+ }
+ set(
+ $current,
+ "qualifiedName",
+ lv_qualifiedName_2_0,
+ "QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?(
+(
+ {
+ newCompositeNode(grammarAccess.getSuperInvocationExpressionAccess().getTupleTupleParserRuleCall_2_0());
+ }
+ lv_tuple_3_0=ruleTuple {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSuperInvocationExpressionRule());
+ }
+ set(
+ $current,
+ "tuple",
+ lv_tuple_3_0,
+ "Tuple");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleInstanceCreationOrSequenceConstructionExpression
+entryRuleInstanceCreationOrSequenceConstructionExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getInstanceCreationOrSequenceConstructionExpressionRule()); }
+ iv_ruleInstanceCreationOrSequenceConstructionExpression=ruleInstanceCreationOrSequenceConstructionExpression
+ { $current=$iv_ruleInstanceCreationOrSequenceConstructionExpression.current; }
+ EOF
+;
+
+// Rule InstanceCreationOrSequenceConstructionExpression
+ruleInstanceCreationOrSequenceConstructionExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='new'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getInstanceCreationOrSequenceConstructionExpressionAccess().getNewKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getInstanceCreationOrSequenceConstructionExpressionAccess().getQualifiedNameQualifiedNameParserRuleCall_1_0());
+ }
+ lv_qualifiedName_1_0=ruleQualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getInstanceCreationOrSequenceConstructionExpressionRule());
+ }
+ set(
+ $current,
+ "qualifiedName",
+ lv_qualifiedName_1_0,
+ "QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((
+(
+ {
+ newCompositeNode(grammarAccess.getInstanceCreationOrSequenceConstructionExpressionAccess().getSequenceConstructionExpressionCompletionSequenceConstructionExpressionCompletionParserRuleCall_2_0_0());
+ }
+ lv_sequenceConstructionExpressionCompletion_2_0=ruleSequenceConstructionExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getInstanceCreationOrSequenceConstructionExpressionRule());
+ }
+ set(
+ $current,
+ "sequenceConstructionExpressionCompletion",
+ lv_sequenceConstructionExpressionCompletion_2_0,
+ "SequenceConstructionExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getInstanceCreationOrSequenceConstructionExpressionAccess().getTupleTupleParserRuleCall_2_1_0());
+ }
+ lv_tuple_3_0=ruleTuple {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getInstanceCreationOrSequenceConstructionExpressionRule());
+ }
+ set(
+ $current,
+ "tuple",
+ lv_tuple_3_0,
+ "Tuple");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+;
+
+
+
+
+
+// Entry rule entryRuleLinkOperationCompletion
+entryRuleLinkOperationCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getLinkOperationCompletionRule()); }
+ iv_ruleLinkOperationCompletion=ruleLinkOperationCompletion
+ { $current=$iv_ruleLinkOperationCompletion.current; }
+ EOF
+;
+
+// Rule LinkOperationCompletion
+ruleLinkOperationCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getLinkOperationCompletionAccess().getLinkOperationLinkOperationEnumRuleCall_0_0());
+ }
+ lv_linkOperation_0_0=ruleLinkOperation {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLinkOperationCompletionRule());
+ }
+ set(
+ $current,
+ "linkOperation",
+ lv_linkOperation_0_0,
+ "LinkOperation");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getLinkOperationCompletionAccess().getLinkOperationTupleLinkOperationTupleParserRuleCall_1_0());
+ }
+ lv_linkOperationTuple_1_0=ruleLinkOperationTuple {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLinkOperationCompletionRule());
+ }
+ set(
+ $current,
+ "linkOperationTuple",
+ lv_linkOperationTuple_1_0,
+ "LinkOperationTuple");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleLinkOperationTuple
+entryRuleLinkOperationTuple returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getLinkOperationTupleRule()); }
+ iv_ruleLinkOperationTuple=ruleLinkOperationTuple
+ { $current=$iv_ruleLinkOperationTuple.current; }
+ EOF
+;
+
+// Rule LinkOperationTuple
+ruleLinkOperationTuple returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleAction_0(),
+ $current);
+ }
+) otherlv_1='('
+ {
+ newLeafNode(otherlv_1, grammarAccess.getLinkOperationTupleAccess().getLeftParenthesisKeyword_1());
+ }
+((((
+(
+ruleName
+)
+)=>
+(
+ {
+ newCompositeNode(grammarAccess.getLinkOperationTupleAccess().getNameNameParserRuleCall_2_0_0_0());
+ }
+ lv_name_2_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLinkOperationTupleRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_2_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((((
+(
+ruleIndex
+)
+)=>
+(
+ {
+ newCompositeNode(grammarAccess.getLinkOperationTupleAccess().getIndexIndexParserRuleCall_2_0_1_0_0_0());
+ }
+ lv_index_3_0=ruleIndex {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLinkOperationTupleRule());
+ }
+ set(
+ $current,
+ "index",
+ lv_index_3_0,
+ "Index");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(( otherlv_4='=>'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getLinkOperationTupleAccess().getEqualsSignGreaterThanSignKeyword_2_0_1_0_1_0_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getLinkOperationTupleAccess().getIndexNamedExpressionListCompletionIndexedNamedExpressionListCompletionParserRuleCall_2_0_1_0_1_0_1_0());
+ }
+ lv_indexNamedExpressionListCompletion_5_0=ruleIndexedNamedExpressionListCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLinkOperationTupleRule());
+ }
+ set(
+ $current,
+ "indexNamedExpressionListCompletion",
+ lv_indexNamedExpressionListCompletion_5_0,
+ "IndexedNamedExpressionListCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |((
+(
+ {
+ newCompositeNode(grammarAccess.getLinkOperationTupleAccess().getPrimaryToExpressionCompletionPrimaryToExpressionCompletionParserRuleCall_2_0_1_0_1_1_0_0());
+ }
+ lv_primaryToExpressionCompletion_6_0=rulePrimaryToExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLinkOperationTupleRule());
+ }
+ set(
+ $current,
+ "primaryToExpressionCompletion",
+ lv_primaryToExpressionCompletion_6_0,
+ "PrimaryToExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getLinkOperationTupleAccess().getPositionalTupleExpressionListCompletionPositionalTupleExpressionListCompletionParserRuleCall_2_0_1_0_1_1_1_0());
+ }
+ lv_positionalTupleExpressionListCompletion_7_0=rulePositionalTupleExpressionListCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLinkOperationTupleRule());
+ }
+ set(
+ $current,
+ "positionalTupleExpressionListCompletion",
+ lv_positionalTupleExpressionListCompletion_7_0,
+ "PositionalTupleExpressionListCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))))
+ |( otherlv_8='=>'
+ {
+ newLeafNode(otherlv_8, grammarAccess.getLinkOperationTupleAccess().getEqualsSignGreaterThanSignKeyword_2_0_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getLinkOperationTupleAccess().getIndexedNamedExpressionListCompletionIndexedNamedExpressionListCompletionParserRuleCall_2_0_1_1_1_0());
+ }
+ lv_indexedNamedExpressionListCompletion_9_0=ruleIndexedNamedExpressionListCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLinkOperationTupleRule());
+ }
+ set(
+ $current,
+ "indexedNamedExpressionListCompletion",
+ lv_indexedNamedExpressionListCompletion_9_0,
+ "IndexedNamedExpressionListCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getLinkOperationTupleAccess().getPositionalTupleExpressionListCompletionPositionalTupleExpressionListCompletionParserRuleCall_2_0_1_2_0());
+ }
+ lv_positionalTupleExpressionListCompletion_10_0=rulePositionalTupleExpressionListCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLinkOperationTupleRule());
+ }
+ set(
+ $current,
+ "positionalTupleExpressionListCompletion",
+ lv_positionalTupleExpressionListCompletion_10_0,
+ "PositionalTupleExpressionListCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |((
+(
+ {
+ newCompositeNode(grammarAccess.getLinkOperationTupleAccess().getNameToExpressionCompletionNameToExpressionCompletionParserRuleCall_2_0_1_3_0_0());
+ }
+ lv_nameToExpressionCompletion_11_0=ruleNameToExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLinkOperationTupleRule());
+ }
+ set(
+ $current,
+ "nameToExpressionCompletion",
+ lv_nameToExpressionCompletion_11_0,
+ "NameToExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_12=','
+ {
+ newLeafNode(otherlv_12, grammarAccess.getLinkOperationTupleAccess().getCommaKeyword_2_0_1_3_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getLinkOperationTupleAccess().getPositionalTupleExpressionListPositionalTupleExpressionListParserRuleCall_2_0_1_3_2_0());
+ }
+ lv_positionalTupleExpressionList_13_0=rulePositionalTupleExpressionList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLinkOperationTupleRule());
+ }
+ set(
+ $current,
+ "positionalTupleExpressionList",
+ lv_positionalTupleExpressionList_13_0,
+ "PositionalTupleExpressionList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))))
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getLinkOperationTupleAccess().getPositionalTupleExpressionListPositionalTupleExpressionListParserRuleCall_2_1_0());
+ }
+ lv_positionalTupleExpressionList_14_0=rulePositionalTupleExpressionList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLinkOperationTupleRule());
+ }
+ set(
+ $current,
+ "positionalTupleExpressionList",
+ lv_positionalTupleExpressionList_14_0,
+ "PositionalTupleExpressionList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))? otherlv_15=')'
+ {
+ newLeafNode(otherlv_15, grammarAccess.getLinkOperationTupleAccess().getRightParenthesisKeyword_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleIndexedNamedExpressionListCompletion
+entryRuleIndexedNamedExpressionListCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getIndexedNamedExpressionListCompletionRule()); }
+ iv_ruleIndexedNamedExpressionListCompletion=ruleIndexedNamedExpressionListCompletion
+ { $current=$iv_ruleIndexedNamedExpressionListCompletion.current; }
+ EOF
+;
+
+// Rule IndexedNamedExpressionListCompletion
+ruleIndexedNamedExpressionListCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getIndexedNamedExpressionListCompletionAccess().getExpressionExpressionParserRuleCall_0_0());
+ }
+ lv_expression_0_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIndexedNamedExpressionListCompletionRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_0_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=','
+ {
+ newLeafNode(otherlv_1, grammarAccess.getIndexedNamedExpressionListCompletionAccess().getCommaKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getIndexedNamedExpressionListCompletionAccess().getIndexedNamedExpressionIndexedNamedExpressionParserRuleCall_1_1_0());
+ }
+ lv_indexedNamedExpression_2_0=ruleIndexedNamedExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIndexedNamedExpressionListCompletionRule());
+ }
+ add(
+ $current,
+ "indexedNamedExpression",
+ lv_indexedNamedExpression_2_0,
+ "IndexedNamedExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleIndexedNamedExpression
+entryRuleIndexedNamedExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getIndexedNamedExpressionRule()); }
+ iv_ruleIndexedNamedExpression=ruleIndexedNamedExpression
+ { $current=$iv_ruleIndexedNamedExpression.current; }
+ EOF
+;
+
+// Rule IndexedNamedExpression
+ruleIndexedNamedExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getIndexedNamedExpressionAccess().getNameNameParserRuleCall_0_0());
+ }
+ lv_name_0_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIndexedNamedExpressionRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_0_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getIndexedNamedExpressionAccess().getIndexIndexParserRuleCall_1_0());
+ }
+ lv_index_1_0=ruleIndex {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIndexedNamedExpressionRule());
+ }
+ set(
+ $current,
+ "index",
+ lv_index_1_0,
+ "Index");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)? otherlv_2='=>'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getIndexedNamedExpressionAccess().getEqualsSignGreaterThanSignKeyword_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getIndexedNamedExpressionAccess().getExpressionExpressionParserRuleCall_3_0());
+ }
+ lv_expression_3_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIndexedNamedExpressionRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_3_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleClassExtentExpressionCompletion
+entryRuleClassExtentExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassExtentExpressionCompletionRule()); }
+ iv_ruleClassExtentExpressionCompletion=ruleClassExtentExpressionCompletion
+ { $current=$iv_ruleClassExtentExpressionCompletion.current; }
+ EOF
+;
+
+// Rule ClassExtentExpressionCompletion
+ruleClassExtentExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getClassExtentExpressionCompletionAccess().getClassExtentExpressionCompletionAction_0(),
+ $current);
+ }
+) otherlv_1='allInstances'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getClassExtentExpressionCompletionAccess().getAllInstancesKeyword_1());
+ }
+ otherlv_2='('
+ {
+ newLeafNode(otherlv_2, grammarAccess.getClassExtentExpressionCompletionAccess().getLeftParenthesisKeyword_2());
+ }
+ otherlv_3=')'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getClassExtentExpressionCompletionAccess().getRightParenthesisKeyword_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleSequenceAnyExpression
+entryRuleSequenceAnyExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSequenceAnyExpressionRule()); }
+ iv_ruleSequenceAnyExpression=ruleSequenceAnyExpression
+ { $current=$iv_ruleSequenceAnyExpression.current; }
+ EOF
+;
+
+// Rule SequenceAnyExpression
+ruleSequenceAnyExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getSequenceAnyExpressionAccess().getSequenceAnyExpressionAction_0(),
+ $current);
+ }
+)(( otherlv_1='any'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getSequenceAnyExpressionAccess().getAnyKeyword_1_0_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceAnyExpressionAccess().getSequenceConstructionExpressionCompletionSequenceConstructionExpressionCompletionParserRuleCall_1_0_1_0());
+ }
+ lv_sequenceConstructionExpressionCompletion_2_0=ruleSequenceConstructionExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceAnyExpressionRule());
+ }
+ set(
+ $current,
+ "sequenceConstructionExpressionCompletion",
+ lv_sequenceConstructionExpressionCompletion_2_0,
+ "SequenceConstructionExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ | otherlv_3='null'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getSequenceAnyExpressionAccess().getNullKeyword_1_1());
+ }
+))
+;
+
+
+
+
+
+// Entry rule entryRuleSequenceConstructionExpressionCompletion
+entryRuleSequenceConstructionExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSequenceConstructionExpressionCompletionRule()); }
+ iv_ruleSequenceConstructionExpressionCompletion=ruleSequenceConstructionExpressionCompletion
+ { $current=$iv_ruleSequenceConstructionExpressionCompletion.current; }
+ EOF
+;
+
+// Rule SequenceConstructionExpressionCompletion
+ruleSequenceConstructionExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getSequenceConstructionExpressionCompletionAccess().getSequenceConstructionExpressionCompletionAction_0(),
+ $current);
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceConstructionExpressionCompletionAccess().getMultiplicityIndicatorMultiplicityIndicatorParserRuleCall_1_0());
+ }
+ lv_multiplicityIndicator_1_0=ruleMultiplicityIndicator {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceConstructionExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "multiplicityIndicator",
+ lv_multiplicityIndicator_1_0,
+ "MultiplicityIndicator");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)? otherlv_2='{'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getSequenceConstructionExpressionCompletionAccess().getLeftCurlyBracketKeyword_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceConstructionExpressionCompletionAccess().getSequenceElementsSequenceElementsParserRuleCall_3_0());
+ }
+ lv_sequenceElements_3_0=ruleSequenceElements {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceConstructionExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "sequenceElements",
+ lv_sequenceElements_3_0,
+ "SequenceElements");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)? otherlv_4='}'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getSequenceConstructionExpressionCompletionAccess().getRightCurlyBracketKeyword_4());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleMultiplicityIndicator
+entryRuleMultiplicityIndicator returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getMultiplicityIndicatorRule()); }
+ iv_ruleMultiplicityIndicator=ruleMultiplicityIndicator
+ { $current=$iv_ruleMultiplicityIndicator.current; }
+ EOF
+;
+
+// Rule MultiplicityIndicator
+ruleMultiplicityIndicator returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getMultiplicityIndicatorAccess().getMultiplicityIndicatorAction_0(),
+ $current);
+ }
+) otherlv_1='['
+ {
+ newLeafNode(otherlv_1, grammarAccess.getMultiplicityIndicatorAccess().getLeftSquareBracketKeyword_1());
+ }
+ otherlv_2=']'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getMultiplicityIndicatorAccess().getRightSquareBracketKeyword_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleSequenceElements
+entryRuleSequenceElements returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSequenceElementsRule()); }
+ iv_ruleSequenceElements=ruleSequenceElements
+ { $current=$iv_ruleSequenceElements.current; }
+ EOF
+;
+
+// Rule SequenceElements
+ruleSequenceElements returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceElementsAccess().getExpression1ExpressionParserRuleCall_0_0_0());
+ }
+ lv_expression1_0_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceElementsRule());
+ }
+ set(
+ $current,
+ "expression1",
+ lv_expression1_0_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(( otherlv_1='..'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getSequenceElementsAccess().getFullStopFullStopKeyword_0_1_0_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceElementsAccess().getExpression2ExpressionParserRuleCall_0_1_0_1_0());
+ }
+ lv_expression2_2_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceElementsRule());
+ }
+ set(
+ $current,
+ "expression2",
+ lv_expression2_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceElementsAccess().getSequenceElementListCompletionSequenceElementListCompletionParserRuleCall_0_1_1_0());
+ }
+ lv_sequenceElementListCompletion_3_0=ruleSequenceElementListCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceElementsRule());
+ }
+ set(
+ $current,
+ "sequenceElementListCompletion",
+ lv_sequenceElementListCompletion_3_0,
+ "SequenceElementListCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ |((
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceElementsAccess().getSequenceInitializationExpressionSequenceInitializationExpressionParserRuleCall_1_0_0());
+ }
+ lv_sequenceInitializationExpression_4_0=ruleSequenceInitializationExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceElementsRule());
+ }
+ set(
+ $current,
+ "sequenceInitializationExpression",
+ lv_sequenceInitializationExpression_4_0,
+ "SequenceInitializationExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceElementsAccess().getSequenceElementListCompletionSequenceElementListCompletionParserRuleCall_1_1_0());
+ }
+ lv_sequenceElementListCompletion_5_0=ruleSequenceElementListCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceElementsRule());
+ }
+ set(
+ $current,
+ "sequenceElementListCompletion",
+ lv_sequenceElementListCompletion_5_0,
+ "SequenceElementListCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+;
+
+
+
+
+
+// Entry rule entryRuleSequenceElementListCompletion
+entryRuleSequenceElementListCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSequenceElementListCompletionRule()); }
+ iv_ruleSequenceElementListCompletion=ruleSequenceElementListCompletion
+ { $current=$iv_ruleSequenceElementListCompletion.current; }
+ EOF
+;
+
+// Rule SequenceElementListCompletion
+ruleSequenceElementListCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getSequenceElementListCompletionAccess().getSequenceElementListCompletionAction_0(),
+ $current);
+ }
+)( otherlv_1=','
+ {
+ newLeafNode(otherlv_1, grammarAccess.getSequenceElementListCompletionAccess().getCommaKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceElementListCompletionAccess().getSequenceElementSequenceElementParserRuleCall_1_1_0());
+ }
+ lv_sequenceElement_2_0=ruleSequenceElement {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceElementListCompletionRule());
+ }
+ add(
+ $current,
+ "sequenceElement",
+ lv_sequenceElement_2_0,
+ "SequenceElement");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*( otherlv_3=','
+ {
+ newLeafNode(otherlv_3, grammarAccess.getSequenceElementListCompletionAccess().getCommaKeyword_2());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleSequenceElement
+entryRuleSequenceElement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSequenceElementRule()); }
+ iv_ruleSequenceElement=ruleSequenceElement
+ { $current=$iv_ruleSequenceElement.current; }
+ EOF
+;
+
+// Rule SequenceElement
+ruleSequenceElement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceElementAccess().getExpressionExpressionParserRuleCall_0_0());
+ }
+ lv_expression_0_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceElementRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_0_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceElementAccess().getSequenceInitializationExpressionSequenceInitializationExpressionParserRuleCall_1_0());
+ }
+ lv_sequenceInitializationExpression_1_0=ruleSequenceInitializationExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceElementRule());
+ }
+ set(
+ $current,
+ "sequenceInitializationExpression",
+ lv_sequenceInitializationExpression_1_0,
+ "SequenceInitializationExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleSequenceInitializationExpression
+entryRuleSequenceInitializationExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSequenceInitializationExpressionRule()); }
+ iv_ruleSequenceInitializationExpression=ruleSequenceInitializationExpression
+ { $current=$iv_ruleSequenceInitializationExpression.current; }
+ EOF
+;
+
+// Rule SequenceInitializationExpression
+ruleSequenceInitializationExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_isNew_0_0= 'new'
+ {
+ newLeafNode(lv_isNew_0_0, grammarAccess.getSequenceInitializationExpressionAccess().getIsNewNewKeyword_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getSequenceInitializationExpressionRule());
+ }
+ setWithLastConsumed($current, "isNew", true, "new");
+ }
+
+)
+)? otherlv_1='{'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getSequenceInitializationExpressionAccess().getLeftCurlyBracketKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceInitializationExpressionAccess().getSequenceElementsSequenceElementsParserRuleCall_2_0());
+ }
+ lv_sequenceElements_2_0=ruleSequenceElements {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceInitializationExpressionRule());
+ }
+ set(
+ $current,
+ "sequenceElements",
+ lv_sequenceElements_2_0,
+ "SequenceElements");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_3='}'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getSequenceInitializationExpressionAccess().getRightCurlyBracketKeyword_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleIndex
+entryRuleIndex returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getIndexRule()); }
+ iv_ruleIndex=ruleIndex
+ { $current=$iv_ruleIndex.current; }
+ EOF
+;
+
+// Rule Index
+ruleIndex returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='['
+ {
+ newLeafNode(otherlv_0, grammarAccess.getIndexAccess().getLeftSquareBracketKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getIndexAccess().getExpressionExpressionParserRuleCall_1_0());
+ }
+ lv_expression_1_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIndexRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_2=']'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getIndexAccess().getRightSquareBracketKeyword_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleSequenceOperationOrReductionOrExpansion
+entryRuleSequenceOperationOrReductionOrExpansion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSequenceOperationOrReductionOrExpansionRule()); }
+ iv_ruleSequenceOperationOrReductionOrExpansion=ruleSequenceOperationOrReductionOrExpansion
+ { $current=$iv_ruleSequenceOperationOrReductionOrExpansion.current; }
+ EOF
+;
+
+// Rule SequenceOperationOrReductionOrExpansion
+ruleSequenceOperationOrReductionOrExpansion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='->'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getSequenceOperationOrReductionOrExpansionAccess().getHyphenMinusGreaterThanSignKeyword_0());
+ }
+(((
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceOperationOrReductionOrExpansionAccess().getQualifiedNameQualifiedNameParserRuleCall_1_0_0_0());
+ }
+ lv_qualifiedName_1_0=ruleQualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceOperationOrReductionOrExpansionRule());
+ }
+ set(
+ $current,
+ "qualifiedName",
+ lv_qualifiedName_1_0,
+ "QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceOperationOrReductionOrExpansionAccess().getTupleTupleParserRuleCall_1_0_1_0());
+ }
+ lv_tuple_2_0=ruleTuple {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceOperationOrReductionOrExpansionRule());
+ }
+ set(
+ $current,
+ "tuple",
+ lv_tuple_2_0,
+ "Tuple");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |((
+(
+ lv_isReduce_3_0= 'reduce'
+ {
+ newLeafNode(lv_isReduce_3_0, grammarAccess.getSequenceOperationOrReductionOrExpansionAccess().getIsReduceReduceKeyword_1_1_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getSequenceOperationOrReductionOrExpansionRule());
+ }
+ setWithLastConsumed($current, "isReduce", true, "reduce");
+ }
+
+)
+)(
+(
+ lv_isOrdered_4_0= 'ordered'
+ {
+ newLeafNode(lv_isOrdered_4_0, grammarAccess.getSequenceOperationOrReductionOrExpansionAccess().getIsOrderedOrderedKeyword_1_1_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getSequenceOperationOrReductionOrExpansionRule());
+ }
+ setWithLastConsumed($current, "isOrdered", true, "ordered");
+ }
+
+)
+)?((
+(
+ruleQualifiedNameWithoutBinding
+)
+)=>
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceOperationOrReductionOrExpansionAccess().getQualifiedNameQualifiedNameWithoutBindingParserRuleCall_1_1_2_0());
+ }
+ lv_qualifiedName_5_0=ruleQualifiedNameWithoutBinding {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceOperationOrReductionOrExpansionRule());
+ }
+ set(
+ $current,
+ "qualifiedName",
+ lv_qualifiedName_5_0,
+ "QualifiedNameWithoutBinding");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((
+(
+ruleTemplateBinding
+)
+)=>
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceOperationOrReductionOrExpansionAccess().getTemplateBindingTemplateBindingParserRuleCall_1_1_3_0());
+ }
+ lv_templateBinding_6_0=ruleTemplateBinding {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceOperationOrReductionOrExpansionRule());
+ }
+ set(
+ $current,
+ "templateBinding",
+ lv_templateBinding_6_0,
+ "TemplateBinding");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+ |((
+(
+ lv_id_7_0=RULE_ID
+ {
+ newLeafNode(lv_id_7_0, grammarAccess.getSequenceOperationOrReductionOrExpansionAccess().getIdIDTerminalRuleCall_1_2_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getSequenceOperationOrReductionOrExpansionRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "id",
+ lv_id_7_0,
+ "ID");
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceOperationOrReductionOrExpansionAccess().getNameNameParserRuleCall_1_2_1_0());
+ }
+ lv_name_8_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceOperationOrReductionOrExpansionRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_8_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_9='('
+ {
+ newLeafNode(otherlv_9, grammarAccess.getSequenceOperationOrReductionOrExpansionAccess().getLeftParenthesisKeyword_1_2_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getSequenceOperationOrReductionOrExpansionAccess().getExpressionExpressionParserRuleCall_1_2_3_0());
+ }
+ lv_expression_10_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequenceOperationOrReductionOrExpansionRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_10_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_11=')'
+ {
+ newLeafNode(otherlv_11, grammarAccess.getSequenceOperationOrReductionOrExpansionAccess().getRightParenthesisKeyword_1_2_4());
+ }
+)))
+;
+
+
+
+
+
+// Entry rule entryRulePostfixExpressionCompletion
+entryRulePostfixExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPostfixExpressionCompletionRule()); }
+ iv_rulePostfixExpressionCompletion=rulePostfixExpressionCompletion
+ { $current=$iv_rulePostfixExpressionCompletion.current; }
+ EOF
+;
+
+// Rule PostfixExpressionCompletion
+rulePostfixExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixExpressionCompletionAccess().getPrimaryExpressionCompletionPrimaryExpressionCompletionParserRuleCall_0_0_0());
+ }
+ lv_primaryExpressionCompletion_0_0=rulePrimaryExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "primaryExpressionCompletion",
+ lv_primaryExpressionCompletion_0_0,
+ "PrimaryExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixExpressionCompletionAccess().getPostfixOperationPostfixOperationParserRuleCall_0_1_0());
+ }
+ lv_postfixOperation_1_0=rulePostfixOperation {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "postfixOperation",
+ lv_postfixOperation_1_0,
+ "PostfixOperation");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixExpressionCompletionAccess().getPostfixOperationPostfixOperationParserRuleCall_1_0());
+ }
+ lv_postfixOperation_2_0=rulePostfixOperation {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "postfixOperation",
+ lv_postfixOperation_2_0,
+ "PostfixOperation");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRulePostfixOperation
+entryRulePostfixOperation returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPostfixOperationRule()); }
+ iv_rulePostfixOperation=rulePostfixOperation
+ { $current=$iv_rulePostfixOperation.current; }
+ EOF
+;
+
+// Rule PostfixOperation
+rulePostfixOperation returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixOperationAccess().getOperatorAffixOperatorEnumRuleCall_0());
+ }
+ lv_operator_0_0=ruleAffixOperator {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixOperationRule());
+ }
+ set(
+ $current,
+ "operator",
+ lv_operator_0_0,
+ "AffixOperator");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+;
+
+
+
+
+
+// Entry rule entryRulePrefixExpression
+entryRulePrefixExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPrefixExpressionRule()); }
+ iv_rulePrefixExpression=rulePrefixExpression
+ { $current=$iv_rulePrefixExpression.current; }
+ EOF
+;
+
+// Rule PrefixExpression
+rulePrefixExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getPrefixExpressionAccess().getOperatorAffixOperatorEnumRuleCall_0_0());
+ }
+ lv_operator_0_0=ruleAffixOperator {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrefixExpressionRule());
+ }
+ set(
+ $current,
+ "operator",
+ lv_operator_0_0,
+ "AffixOperator");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPrefixExpressionAccess().getPrimaryExpressionPrimaryExpressionParserRuleCall_1_0());
+ }
+ lv_primaryExpression_1_0=rulePrimaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrefixExpressionRule());
+ }
+ set(
+ $current,
+ "primaryExpression",
+ lv_primaryExpression_1_0,
+ "PrimaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleUnaryExpression
+entryRuleUnaryExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getUnaryExpressionRule()); }
+ iv_ruleUnaryExpression=ruleUnaryExpression
+ { $current=$iv_ruleUnaryExpression.current; }
+ EOF
+;
+
+// Rule UnaryExpression
+ruleUnaryExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getUnaryExpressionAccess().getPostfixOrCastExpressionParserRuleCall_0());
+ }
+ this_PostfixOrCastExpression_0=rulePostfixOrCastExpression
+ {
+ $current = $this_PostfixOrCastExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getUnaryExpressionAccess().getNonPostfixNonCastUnaryExpressionParserRuleCall_1());
+ }
+ this_NonPostfixNonCastUnaryExpression_1=ruleNonPostfixNonCastUnaryExpression
+ {
+ $current = $this_NonPostfixNonCastUnaryExpression_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRulePostfixOrCastExpression
+entryRulePostfixOrCastExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPostfixOrCastExpressionRule()); }
+ iv_rulePostfixOrCastExpression=rulePostfixOrCastExpression
+ { $current=$iv_rulePostfixOrCastExpression.current; }
+ EOF
+;
+
+// Rule PostfixOrCastExpression
+rulePostfixOrCastExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixOrCastExpressionAccess().getNonNamePostfixOrCastExpressionNonNamePostfixOrCastExpressionParserRuleCall_0_0());
+ }
+ lv_nonNamePostfixOrCastExpression_0_0=ruleNonNamePostfixOrCastExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixOrCastExpressionRule());
+ }
+ set(
+ $current,
+ "nonNamePostfixOrCastExpression",
+ lv_nonNamePostfixOrCastExpression_0_0,
+ "NonNamePostfixOrCastExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |((
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixOrCastExpressionAccess().getNameOrPrimaryExpressionNameOrPrimaryExpressionParserRuleCall_1_0_0());
+ }
+ lv_nameOrPrimaryExpression_1_0=ruleNameOrPrimaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixOrCastExpressionRule());
+ }
+ set(
+ $current,
+ "nameOrPrimaryExpression",
+ lv_nameOrPrimaryExpression_1_0,
+ "NameOrPrimaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixOrCastExpressionAccess().getPostFixExpressionCompletionPostfixExpressionCompletionParserRuleCall_1_1_0());
+ }
+ lv_postFixExpressionCompletion_2_0=rulePostfixExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixOrCastExpressionRule());
+ }
+ set(
+ $current,
+ "postFixExpressionCompletion",
+ lv_postFixExpressionCompletion_2_0,
+ "PostfixExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?))
+;
+
+
+
+
+
+// Entry rule entryRuleNonNameUnaryExpression
+entryRuleNonNameUnaryExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNonNameUnaryExpressionRule()); }
+ iv_ruleNonNameUnaryExpression=ruleNonNameUnaryExpression
+ { $current=$iv_ruleNonNameUnaryExpression.current; }
+ EOF
+;
+
+// Rule NonNameUnaryExpression
+ruleNonNameUnaryExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getNonNameUnaryExpressionAccess().getNonNamePostfixOrCastExpressionParserRuleCall_0());
+ }
+ this_NonNamePostfixOrCastExpression_0=ruleNonNamePostfixOrCastExpression
+ {
+ $current = $this_NonNamePostfixOrCastExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getNonNameUnaryExpressionAccess().getNonPostfixNonCastUnaryExpressionParserRuleCall_1());
+ }
+ this_NonPostfixNonCastUnaryExpression_1=ruleNonPostfixNonCastUnaryExpression
+ {
+ $current = $this_NonPostfixNonCastUnaryExpression_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleNonNamePostfixOrCastExpression
+entryRuleNonNamePostfixOrCastExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNonNamePostfixOrCastExpressionRule()); }
+ iv_ruleNonNamePostfixOrCastExpression=ruleNonNamePostfixOrCastExpression
+ { $current=$iv_ruleNonNamePostfixOrCastExpression.current; }
+ EOF
+;
+
+// Rule NonNamePostfixOrCastExpression
+ruleNonNamePostfixOrCastExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(( otherlv_0='('
+ {
+ newLeafNode(otherlv_0, grammarAccess.getNonNamePostfixOrCastExpressionAccess().getLeftParenthesisKeyword_0_0());
+ }
+(((
+(
+ lv_any_1_0= 'any'
+ {
+ newLeafNode(lv_any_1_0, grammarAccess.getNonNamePostfixOrCastExpressionAccess().getAnyAnyKeyword_0_1_0_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getNonNamePostfixOrCastExpressionRule());
+ }
+ setWithLastConsumed($current, "any", true, "any");
+ }
+
+)
+) otherlv_2=')'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getNonNamePostfixOrCastExpressionAccess().getRightParenthesisKeyword_0_1_0_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getNonNamePostfixOrCastExpressionAccess().getCastCompletionCastCompletionParserRuleCall_0_1_0_2_0());
+ }
+ lv_castCompletion_3_0=ruleCastCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNonNamePostfixOrCastExpressionRule());
+ }
+ set(
+ $current,
+ "castCompletion",
+ lv_castCompletion_3_0,
+ "CastCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |((
+(
+ {
+ newCompositeNode(grammarAccess.getNonNamePostfixOrCastExpressionAccess().getPotentiallyAmbiguousQualifiedNameQualifiedNameWithoutBindingParserRuleCall_0_1_1_0_0());
+ }
+ lv_potentiallyAmbiguousQualifiedName_4_0=ruleQualifiedNameWithoutBinding {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNonNamePostfixOrCastExpressionRule());
+ }
+ set(
+ $current,
+ "potentiallyAmbiguousQualifiedName",
+ lv_potentiallyAmbiguousQualifiedName_4_0,
+ "QualifiedNameWithoutBinding");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(( otherlv_5=')'
+ {
+ newLeafNode(otherlv_5, grammarAccess.getNonNamePostfixOrCastExpressionAccess().getRightParenthesisKeyword_0_1_1_1_0_0());
+ }
+(((
+(
+ruleCastCompletion
+)
+)=>
+(
+ {
+ newCompositeNode(grammarAccess.getNonNamePostfixOrCastExpressionAccess().getCastCompletionCastCompletionParserRuleCall_0_1_1_1_0_1_0_0());
+ }
+ lv_castCompletion_6_0=ruleCastCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNonNamePostfixOrCastExpressionRule());
+ }
+ set(
+ $current,
+ "castCompletion",
+ lv_castCompletion_6_0,
+ "CastCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getNonNamePostfixOrCastExpressionAccess().getPostifixExpressionCompletionPostfixExpressionCompletionParserRuleCall_0_1_1_1_0_1_1_0());
+ }
+ lv_postifixExpressionCompletion_7_0=rulePostfixExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNonNamePostfixOrCastExpressionRule());
+ }
+ set(
+ $current,
+ "postifixExpressionCompletion",
+ lv_postifixExpressionCompletion_7_0,
+ "PostfixExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+ |((
+(
+ {
+ newCompositeNode(grammarAccess.getNonNamePostfixOrCastExpressionAccess().getNameToExpressionCompletionNameToExpressionCompletionParserRuleCall_0_1_1_1_1_0_0());
+ }
+ lv_nameToExpressionCompletion_8_0=ruleNameToExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNonNamePostfixOrCastExpressionRule());
+ }
+ set(
+ $current,
+ "nameToExpressionCompletion",
+ lv_nameToExpressionCompletion_8_0,
+ "NameToExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_9=')'
+ {
+ newLeafNode(otherlv_9, grammarAccess.getNonNamePostfixOrCastExpressionAccess().getRightParenthesisKeyword_0_1_1_1_1_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getNonNamePostfixOrCastExpressionAccess().getPostfixExpressionCompletionPostfixExpressionCompletionParserRuleCall_0_1_1_1_1_2_0());
+ }
+ lv_postfixExpressionCompletion_10_0=rulePostfixExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNonNamePostfixOrCastExpressionRule());
+ }
+ set(
+ $current,
+ "postfixExpressionCompletion",
+ lv_postfixExpressionCompletion_10_0,
+ "PostfixExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)))
+ |((
+(
+ {
+ newCompositeNode(grammarAccess.getNonNamePostfixOrCastExpressionAccess().getNonNameExpressionNonNameExpressionParserRuleCall_0_1_2_0_0());
+ }
+ lv_nonNameExpression_11_0=ruleNonNameExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNonNamePostfixOrCastExpressionRule());
+ }
+ set(
+ $current,
+ "nonNameExpression",
+ lv_nonNameExpression_11_0,
+ "NonNameExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_12=')'
+ {
+ newLeafNode(otherlv_12, grammarAccess.getNonNamePostfixOrCastExpressionAccess().getRightParenthesisKeyword_0_1_2_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getNonNamePostfixOrCastExpressionAccess().getPostfixExpressionCompletionPostfixExpressionCompletionParserRuleCall_0_1_2_2_0());
+ }
+ lv_postfixExpressionCompletion_13_0=rulePostfixExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNonNamePostfixOrCastExpressionRule());
+ }
+ set(
+ $current,
+ "postfixExpressionCompletion",
+ lv_postfixExpressionCompletion_13_0,
+ "PostfixExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)))
+ |((
+(
+ {
+ newCompositeNode(grammarAccess.getNonNamePostfixOrCastExpressionAccess().getBaseExpressionBaseExpressionParserRuleCall_1_0_0());
+ }
+ lv_baseExpression_14_0=ruleBaseExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNonNamePostfixOrCastExpressionRule());
+ }
+ set(
+ $current,
+ "baseExpression",
+ lv_baseExpression_14_0,
+ "BaseExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getNonNamePostfixOrCastExpressionAccess().getPostfixExpressionCompletionPostfixExpressionCompletionParserRuleCall_1_1_0());
+ }
+ lv_postfixExpressionCompletion_15_0=rulePostfixExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNonNamePostfixOrCastExpressionRule());
+ }
+ set(
+ $current,
+ "postfixExpressionCompletion",
+ lv_postfixExpressionCompletion_15_0,
+ "PostfixExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?))
+;
+
+
+
+
+
+// Entry rule entryRuleNonPostfixNonCastUnaryExpression
+entryRuleNonPostfixNonCastUnaryExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNonPostfixNonCastUnaryExpressionRule()); }
+ iv_ruleNonPostfixNonCastUnaryExpression=ruleNonPostfixNonCastUnaryExpression
+ { $current=$iv_ruleNonPostfixNonCastUnaryExpression.current; }
+ EOF
+;
+
+// Rule NonPostfixNonCastUnaryExpression
+ruleNonPostfixNonCastUnaryExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getNonPostfixNonCastUnaryExpressionAccess().getPrefixExpressionParserRuleCall_0());
+ }
+ this_PrefixExpression_0=rulePrefixExpression
+ {
+ $current = $this_PrefixExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getNonPostfixNonCastUnaryExpressionAccess().getNumericUnaryExpressionParserRuleCall_1());
+ }
+ this_NumericUnaryExpression_1=ruleNumericUnaryExpression
+ {
+ $current = $this_NumericUnaryExpression_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getNonPostfixNonCastUnaryExpressionAccess().getBooleanNegationExpressionParserRuleCall_2());
+ }
+ this_BooleanNegationExpression_2=ruleBooleanNegationExpression
+ {
+ $current = $this_BooleanNegationExpression_2.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getNonPostfixNonCastUnaryExpressionAccess().getBitStringComplementExpressionParserRuleCall_3());
+ }
+ this_BitStringComplementExpression_3=ruleBitStringComplementExpression
+ {
+ $current = $this_BitStringComplementExpression_3.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getNonPostfixNonCastUnaryExpressionAccess().getIsolationExpressionParserRuleCall_4());
+ }
+ this_IsolationExpression_4=ruleIsolationExpression
+ {
+ $current = $this_IsolationExpression_4.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleBooleanNegationExpression
+entryRuleBooleanNegationExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getBooleanNegationExpressionRule()); }
+ iv_ruleBooleanNegationExpression=ruleBooleanNegationExpression
+ { $current=$iv_ruleBooleanNegationExpression.current; }
+ EOF
+;
+
+// Rule BooleanNegationExpression
+ruleBooleanNegationExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='!'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getBooleanNegationExpressionAccess().getExclamationMarkKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getBooleanNegationExpressionAccess().getUnaryExpressionUnaryExpressionParserRuleCall_1_0());
+ }
+ lv_unaryExpression_1_0=ruleUnaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getBooleanNegationExpressionRule());
+ }
+ set(
+ $current,
+ "unaryExpression",
+ lv_unaryExpression_1_0,
+ "UnaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleBitStringComplementExpression
+entryRuleBitStringComplementExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getBitStringComplementExpressionRule()); }
+ iv_ruleBitStringComplementExpression=ruleBitStringComplementExpression
+ { $current=$iv_ruleBitStringComplementExpression.current; }
+ EOF
+;
+
+// Rule BitStringComplementExpression
+ruleBitStringComplementExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='~'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getBitStringComplementExpressionAccess().getTildeKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getBitStringComplementExpressionAccess().getUnaryExpressionUnaryExpressionParserRuleCall_1_0());
+ }
+ lv_unaryExpression_1_0=ruleUnaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getBitStringComplementExpressionRule());
+ }
+ set(
+ $current,
+ "unaryExpression",
+ lv_unaryExpression_1_0,
+ "UnaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleNumericUnaryExpression
+entryRuleNumericUnaryExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNumericUnaryExpressionRule()); }
+ iv_ruleNumericUnaryExpression=ruleNumericUnaryExpression
+ { $current=$iv_ruleNumericUnaryExpression.current; }
+ EOF
+;
+
+// Rule NumericUnaryExpression
+ruleNumericUnaryExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getNumericUnaryExpressionAccess().getOperatorNumericUnaryOperatorEnumRuleCall_0_0());
+ }
+ lv_operator_0_0=ruleNumericUnaryOperator {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNumericUnaryExpressionRule());
+ }
+ set(
+ $current,
+ "operator",
+ lv_operator_0_0,
+ "NumericUnaryOperator");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getNumericUnaryExpressionAccess().getUnaryExpressionUnaryExpressionParserRuleCall_1_0());
+ }
+ lv_unaryExpression_1_0=ruleUnaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNumericUnaryExpressionRule());
+ }
+ set(
+ $current,
+ "unaryExpression",
+ lv_unaryExpression_1_0,
+ "UnaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleIsolationExpression
+entryRuleIsolationExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getIsolationExpressionRule()); }
+ iv_ruleIsolationExpression=ruleIsolationExpression
+ { $current=$iv_ruleIsolationExpression.current; }
+ EOF
+;
+
+// Rule IsolationExpression
+ruleIsolationExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='$'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getIsolationExpressionAccess().getDollarSignKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getIsolationExpressionAccess().getUnaryExpressionUnaryExpressionParserRuleCall_1_0());
+ }
+ lv_unaryExpression_1_0=ruleUnaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIsolationExpressionRule());
+ }
+ set(
+ $current,
+ "unaryExpression",
+ lv_unaryExpression_1_0,
+ "UnaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleCastCompletion
+entryRuleCastCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getCastCompletionRule()); }
+ iv_ruleCastCompletion=ruleCastCompletion
+ { $current=$iv_ruleCastCompletion.current; }
+ EOF
+;
+
+// Rule CastCompletion
+ruleCastCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getCastCompletionAccess().getPostfixOrCastExpressionParserRuleCall_0());
+ }
+ this_PostfixOrCastExpression_0=rulePostfixOrCastExpression
+ {
+ $current = $this_PostfixOrCastExpression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getCastCompletionAccess().getBooleanNegationExpressionParserRuleCall_1());
+ }
+ this_BooleanNegationExpression_1=ruleBooleanNegationExpression
+ {
+ $current = $this_BooleanNegationExpression_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getCastCompletionAccess().getBitStringComplementExpressionParserRuleCall_2());
+ }
+ this_BitStringComplementExpression_2=ruleBitStringComplementExpression
+ {
+ $current = $this_BitStringComplementExpression_2.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getCastCompletionAccess().getIsolationExpressionParserRuleCall_3());
+ }
+ this_IsolationExpression_3=ruleIsolationExpression
+ {
+ $current = $this_IsolationExpression_3.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleMultiplicativeExpression
+entryRuleMultiplicativeExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getMultiplicativeExpressionRule()); }
+ iv_ruleMultiplicativeExpression=ruleMultiplicativeExpression
+ { $current=$iv_ruleMultiplicativeExpression.current; }
+ EOF
+;
+
+// Rule MultiplicativeExpression
+ruleMultiplicativeExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getUnaryExpressionUnaryExpressionParserRuleCall_0_0());
+ }
+ lv_unaryExpression_0_0=ruleUnaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule());
+ }
+ set(
+ $current,
+ "unaryExpression",
+ lv_unaryExpression_0_0,
+ "UnaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getMultiplicativeExpressionCompletionMultiplicativeExpressionCompletionParserRuleCall_1_0());
+ }
+ lv_multiplicativeExpressionCompletion_1_0=ruleMultiplicativeExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule());
+ }
+ set(
+ $current,
+ "multiplicativeExpressionCompletion",
+ lv_multiplicativeExpressionCompletion_1_0,
+ "MultiplicativeExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleMultiplicativeExpressionCompletion
+entryRuleMultiplicativeExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getMultiplicativeExpressionCompletionRule()); }
+ iv_ruleMultiplicativeExpressionCompletion=ruleMultiplicativeExpressionCompletion
+ { $current=$iv_ruleMultiplicativeExpressionCompletion.current; }
+ EOF
+;
+
+// Rule MultiplicativeExpressionCompletion
+ruleMultiplicativeExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getMultiplicativeExpressionCompletionAccess().getMultiplicativeExpressionCompletionAction_0(),
+ $current);
+ }
+)((
+(
+ {
+ newCompositeNode(grammarAccess.getMultiplicativeExpressionCompletionAccess().getOperatorMultiplicativeOperatorEnumRuleCall_1_0_0());
+ }
+ lv_operator_1_0=ruleMultiplicativeOperator {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionCompletionRule());
+ }
+ add(
+ $current,
+ "operator",
+ lv_operator_1_0,
+ "MultiplicativeOperator");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getMultiplicativeExpressionCompletionAccess().getUnaryExpressionUnaryExpressionParserRuleCall_1_1_0());
+ }
+ lv_unaryExpression_2_0=ruleUnaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionCompletionRule());
+ }
+ add(
+ $current,
+ "unaryExpression",
+ lv_unaryExpression_2_0,
+ "UnaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleAdditiveExpression
+entryRuleAdditiveExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAdditiveExpressionRule()); }
+ iv_ruleAdditiveExpression=ruleAdditiveExpression
+ { $current=$iv_ruleAdditiveExpression.current; }
+ EOF
+;
+
+// Rule AdditiveExpression
+ruleAdditiveExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getUnaryExpressionUnaryExpressionParserRuleCall_0_0());
+ }
+ lv_unaryExpression_0_0=ruleUnaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule());
+ }
+ set(
+ $current,
+ "unaryExpression",
+ lv_unaryExpression_0_0,
+ "UnaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getAdditiveExpressionCompletionAdditiveExpressionCompletionParserRuleCall_1_0());
+ }
+ lv_additiveExpressionCompletion_1_0=ruleAdditiveExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule());
+ }
+ set(
+ $current,
+ "additiveExpressionCompletion",
+ lv_additiveExpressionCompletion_1_0,
+ "AdditiveExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleAdditiveExpressionCompletion
+entryRuleAdditiveExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAdditiveExpressionCompletionRule()); }
+ iv_ruleAdditiveExpressionCompletion=ruleAdditiveExpressionCompletion
+ { $current=$iv_ruleAdditiveExpressionCompletion.current; }
+ EOF
+;
+
+// Rule AdditiveExpressionCompletion
+ruleAdditiveExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getAdditiveExpressionCompletionAccess().getMultiplicativeExpressionCompletionMultiplicativeExpressionCompletionParserRuleCall_0_0());
+ }
+ lv_multiplicativeExpressionCompletion_0_0=ruleMultiplicativeExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAdditiveExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "multiplicativeExpressionCompletion",
+ lv_multiplicativeExpressionCompletion_0_0,
+ "MultiplicativeExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((
+(
+ {
+ newCompositeNode(grammarAccess.getAdditiveExpressionCompletionAccess().getOperatorAdditiveOperatorEnumRuleCall_1_0_0());
+ }
+ lv_operator_1_0=ruleAdditiveOperator {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAdditiveExpressionCompletionRule());
+ }
+ add(
+ $current,
+ "operator",
+ lv_operator_1_0,
+ "AdditiveOperator");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getAdditiveExpressionCompletionAccess().getMultiplicativeExpressionMultiplicativeExpressionParserRuleCall_1_1_0());
+ }
+ lv_multiplicativeExpression_2_0=ruleMultiplicativeExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAdditiveExpressionCompletionRule());
+ }
+ add(
+ $current,
+ "multiplicativeExpression",
+ lv_multiplicativeExpression_2_0,
+ "MultiplicativeExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleShiftExpression
+entryRuleShiftExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getShiftExpressionRule()); }
+ iv_ruleShiftExpression=ruleShiftExpression
+ { $current=$iv_ruleShiftExpression.current; }
+ EOF
+;
+
+// Rule ShiftExpression
+ruleShiftExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getShiftExpressionAccess().getUnaryExpressionUnaryExpressionParserRuleCall_0_0());
+ }
+ lv_unaryExpression_0_0=ruleUnaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getShiftExpressionRule());
+ }
+ set(
+ $current,
+ "unaryExpression",
+ lv_unaryExpression_0_0,
+ "UnaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getShiftExpressionAccess().getShiftExpressionCompletionShiftExpressionCompletionParserRuleCall_1_0());
+ }
+ lv_shiftExpressionCompletion_1_0=ruleShiftExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getShiftExpressionRule());
+ }
+ set(
+ $current,
+ "shiftExpressionCompletion",
+ lv_shiftExpressionCompletion_1_0,
+ "ShiftExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleShiftExpressionCompletion
+entryRuleShiftExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getShiftExpressionCompletionRule()); }
+ iv_ruleShiftExpressionCompletion=ruleShiftExpressionCompletion
+ { $current=$iv_ruleShiftExpressionCompletion.current; }
+ EOF
+;
+
+// Rule ShiftExpressionCompletion
+ruleShiftExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getShiftExpressionCompletionAccess().getAdditiveExpressionCompletionAdditiveExpressionCompletionParserRuleCall_0_0());
+ }
+ lv_additiveExpressionCompletion_0_0=ruleAdditiveExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getShiftExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "additiveExpressionCompletion",
+ lv_additiveExpressionCompletion_0_0,
+ "AdditiveExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((
+(
+ {
+ newCompositeNode(grammarAccess.getShiftExpressionCompletionAccess().getOperatorShiftOperatorEnumRuleCall_1_0_0());
+ }
+ lv_operator_1_0=ruleShiftOperator {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getShiftExpressionCompletionRule());
+ }
+ add(
+ $current,
+ "operator",
+ lv_operator_1_0,
+ "ShiftOperator");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getShiftExpressionCompletionAccess().getAdditiveExpressionAdditiveExpressionParserRuleCall_1_1_0());
+ }
+ lv_additiveExpression_2_0=ruleAdditiveExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getShiftExpressionCompletionRule());
+ }
+ add(
+ $current,
+ "additiveExpression",
+ lv_additiveExpression_2_0,
+ "AdditiveExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+
+
+// Entry rule entryRuleRelationalExpressionCompletion
+entryRuleRelationalExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getRelationalExpressionCompletionRule()); }
+ iv_ruleRelationalExpressionCompletion=ruleRelationalExpressionCompletion
+ { $current=$iv_ruleRelationalExpressionCompletion.current; }
+ EOF
+;
+
+// Rule RelationalExpressionCompletion
+ruleRelationalExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getRelationalExpressionCompletionAccess().getShiftExpressionCompletionShiftExpressionCompletionParserRuleCall_0_0());
+ }
+ lv_shiftExpressionCompletion_0_0=ruleShiftExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getRelationalExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "shiftExpressionCompletion",
+ lv_shiftExpressionCompletion_0_0,
+ "ShiftExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((
+(
+ {
+ newCompositeNode(grammarAccess.getRelationalExpressionCompletionAccess().getRelationalOperatorRelationalOperatorEnumRuleCall_1_0_0());
+ }
+ lv_relationalOperator_1_0=ruleRelationalOperator {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getRelationalExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "relationalOperator",
+ lv_relationalOperator_1_0,
+ "RelationalOperator");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getRelationalExpressionCompletionAccess().getShiftExpressionShiftExpressionParserRuleCall_1_1_0());
+ }
+ lv_shiftExpression_2_0=ruleShiftExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getRelationalExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "shiftExpression",
+ lv_shiftExpression_2_0,
+ "ShiftExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleClassificationExpression
+entryRuleClassificationExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassificationExpressionRule()); }
+ iv_ruleClassificationExpression=ruleClassificationExpression
+ { $current=$iv_ruleClassificationExpression.current; }
+ EOF
+;
+
+// Rule ClassificationExpression
+ruleClassificationExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getClassificationExpressionAccess().getUnaryExpressionUnaryExpressionParserRuleCall_0_0());
+ }
+ lv_unaryExpression_0_0=ruleUnaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassificationExpressionRule());
+ }
+ set(
+ $current,
+ "unaryExpression",
+ lv_unaryExpression_0_0,
+ "UnaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getClassificationExpressionAccess().getClassificationExpressionCompletionClassificationExpressionCompletionParserRuleCall_1_0());
+ }
+ lv_classificationExpressionCompletion_1_0=ruleClassificationExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassificationExpressionRule());
+ }
+ set(
+ $current,
+ "classificationExpressionCompletion",
+ lv_classificationExpressionCompletion_1_0,
+ "ClassificationExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleClassificationExpressionCompletion
+entryRuleClassificationExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassificationExpressionCompletionRule()); }
+ iv_ruleClassificationExpressionCompletion=ruleClassificationExpressionCompletion
+ { $current=$iv_ruleClassificationExpressionCompletion.current; }
+ EOF
+;
+
+// Rule ClassificationExpressionCompletion
+ruleClassificationExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getClassificationExpressionCompletionAccess().getRelationalExpressionCompletionRelationalExpressionCompletionParserRuleCall_0_0());
+ }
+ lv_relationalExpressionCompletion_0_0=ruleRelationalExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassificationExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "relationalExpressionCompletion",
+ lv_relationalExpressionCompletion_0_0,
+ "RelationalExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((
+(
+ {
+ newCompositeNode(grammarAccess.getClassificationExpressionCompletionAccess().getOperatorClassificationOperatorEnumRuleCall_1_0_0());
+ }
+ lv_operator_1_0=ruleClassificationOperator {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassificationExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "operator",
+ lv_operator_1_0,
+ "ClassificationOperator");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getClassificationExpressionCompletionAccess().getNameQualifiedNameParserRuleCall_1_1_0());
+ }
+ lv_name_2_0=ruleQualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassificationExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_2_0,
+ "QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleEqualityExpression
+entryRuleEqualityExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getEqualityExpressionRule()); }
+ iv_ruleEqualityExpression=ruleEqualityExpression
+ { $current=$iv_ruleEqualityExpression.current; }
+ EOF
+;
+
+// Rule EqualityExpression
+ruleEqualityExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getEqualityExpressionAccess().getUnaryExpressionUnaryExpressionParserRuleCall_0_0());
+ }
+ lv_unaryExpression_0_0=ruleUnaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEqualityExpressionRule());
+ }
+ set(
+ $current,
+ "unaryExpression",
+ lv_unaryExpression_0_0,
+ "UnaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getEqualityExpressionAccess().getClassificationExpressionCompletionClassificationExpressionCompletionParserRuleCall_1_0());
+ }
+ lv_classificationExpressionCompletion_1_0=ruleClassificationExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEqualityExpressionRule());
+ }
+ set(
+ $current,
+ "classificationExpressionCompletion",
+ lv_classificationExpressionCompletion_1_0,
+ "ClassificationExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleEqualityExpressionCompletion
+entryRuleEqualityExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getEqualityExpressionCompletionRule()); }
+ iv_ruleEqualityExpressionCompletion=ruleEqualityExpressionCompletion
+ { $current=$iv_ruleEqualityExpressionCompletion.current; }
+ EOF
+;
+
+// Rule EqualityExpressionCompletion
+ruleEqualityExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getEqualityExpressionCompletionAccess().getClassificationExpressionCompletionClassificationExpressionCompletionParserRuleCall_0_0());
+ }
+ lv_classificationExpressionCompletion_0_0=ruleClassificationExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEqualityExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "classificationExpressionCompletion",
+ lv_classificationExpressionCompletion_0_0,
+ "ClassificationExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((
+(
+ {
+ newCompositeNode(grammarAccess.getEqualityExpressionCompletionAccess().getOperatorEqualityOperatorEnumRuleCall_1_0_0());
+ }
+ lv_operator_1_0=ruleEqualityOperator {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEqualityExpressionCompletionRule());
+ }
+ add(
+ $current,
+ "operator",
+ lv_operator_1_0,
+ "EqualityOperator");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getEqualityExpressionCompletionAccess().getClassificationExpressionClassificationExpressionParserRuleCall_1_1_0());
+ }
+ lv_classificationExpression_2_0=ruleClassificationExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEqualityExpressionCompletionRule());
+ }
+ add(
+ $current,
+ "classificationExpression",
+ lv_classificationExpression_2_0,
+ "ClassificationExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleAndExpression
+entryRuleAndExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAndExpressionRule()); }
+ iv_ruleAndExpression=ruleAndExpression
+ { $current=$iv_ruleAndExpression.current; }
+ EOF
+;
+
+// Rule AndExpression
+ruleAndExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getAndExpressionAccess().getUnaryExpressionUnaryExpressionParserRuleCall_0_0());
+ }
+ lv_unaryExpression_0_0=ruleUnaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAndExpressionRule());
+ }
+ set(
+ $current,
+ "unaryExpression",
+ lv_unaryExpression_0_0,
+ "UnaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getAndExpressionAccess().getAndExpressionCompletionAndExpressionCompletionParserRuleCall_1_0());
+ }
+ lv_andExpressionCompletion_1_0=ruleAndExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAndExpressionRule());
+ }
+ set(
+ $current,
+ "andExpressionCompletion",
+ lv_andExpressionCompletion_1_0,
+ "AndExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleAndExpressionCompletion
+entryRuleAndExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAndExpressionCompletionRule()); }
+ iv_ruleAndExpressionCompletion=ruleAndExpressionCompletion
+ { $current=$iv_ruleAndExpressionCompletion.current; }
+ EOF
+;
+
+// Rule AndExpressionCompletion
+ruleAndExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getAndExpressionCompletionAccess().getEqualityExpressionCompletionEqualityExpressionCompletionParserRuleCall_0_0());
+ }
+ lv_equalityExpressionCompletion_0_0=ruleEqualityExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAndExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "equalityExpressionCompletion",
+ lv_equalityExpressionCompletion_0_0,
+ "EqualityExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1='&'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getAndExpressionCompletionAccess().getAmpersandKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getAndExpressionCompletionAccess().getEqualityExpressionEqualityExpressionParserRuleCall_1_1_0());
+ }
+ lv_equalityExpression_2_0=ruleEqualityExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAndExpressionCompletionRule());
+ }
+ add(
+ $current,
+ "equalityExpression",
+ lv_equalityExpression_2_0,
+ "EqualityExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleExclusiveOrExpression
+entryRuleExclusiveOrExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getExclusiveOrExpressionRule()); }
+ iv_ruleExclusiveOrExpression=ruleExclusiveOrExpression
+ { $current=$iv_ruleExclusiveOrExpression.current; }
+ EOF
+;
+
+// Rule ExclusiveOrExpression
+ruleExclusiveOrExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getExclusiveOrExpressionAccess().getUnaryExpressionUnaryExpressionParserRuleCall_0_0());
+ }
+ lv_unaryExpression_0_0=ruleUnaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExclusiveOrExpressionRule());
+ }
+ set(
+ $current,
+ "unaryExpression",
+ lv_unaryExpression_0_0,
+ "UnaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getExclusiveOrExpressionAccess().getExclusiveOrExpressionCompletionExclusiveOrExpressionCompletionParserRuleCall_1_0());
+ }
+ lv_exclusiveOrExpressionCompletion_1_0=ruleExclusiveOrExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExclusiveOrExpressionRule());
+ }
+ set(
+ $current,
+ "exclusiveOrExpressionCompletion",
+ lv_exclusiveOrExpressionCompletion_1_0,
+ "ExclusiveOrExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleExclusiveOrExpressionCompletion
+entryRuleExclusiveOrExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getExclusiveOrExpressionCompletionRule()); }
+ iv_ruleExclusiveOrExpressionCompletion=ruleExclusiveOrExpressionCompletion
+ { $current=$iv_ruleExclusiveOrExpressionCompletion.current; }
+ EOF
+;
+
+// Rule ExclusiveOrExpressionCompletion
+ruleExclusiveOrExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getExclusiveOrExpressionCompletionAccess().getAndExpressionCompletionAndExpressionCompletionParserRuleCall_0_0());
+ }
+ lv_andExpressionCompletion_0_0=ruleAndExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExclusiveOrExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "andExpressionCompletion",
+ lv_andExpressionCompletion_0_0,
+ "AndExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1='^'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getExclusiveOrExpressionCompletionAccess().getCircumflexAccentKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getExclusiveOrExpressionCompletionAccess().getAndExpressionAndExpressionParserRuleCall_1_1_0());
+ }
+ lv_andExpression_2_0=ruleAndExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExclusiveOrExpressionCompletionRule());
+ }
+ add(
+ $current,
+ "andExpression",
+ lv_andExpression_2_0,
+ "AndExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleInclusiveOrExpression
+entryRuleInclusiveOrExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getInclusiveOrExpressionRule()); }
+ iv_ruleInclusiveOrExpression=ruleInclusiveOrExpression
+ { $current=$iv_ruleInclusiveOrExpression.current; }
+ EOF
+;
+
+// Rule InclusiveOrExpression
+ruleInclusiveOrExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getInclusiveOrExpressionAccess().getUnaryExpressionUnaryExpressionParserRuleCall_0_0());
+ }
+ lv_unaryExpression_0_0=ruleUnaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getInclusiveOrExpressionRule());
+ }
+ set(
+ $current,
+ "unaryExpression",
+ lv_unaryExpression_0_0,
+ "UnaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getInclusiveOrExpressionAccess().getInclusiveOrExpressionCompletionInclusiveOrExpressionCompletionParserRuleCall_1_0());
+ }
+ lv_inclusiveOrExpressionCompletion_1_0=ruleInclusiveOrExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getInclusiveOrExpressionRule());
+ }
+ set(
+ $current,
+ "inclusiveOrExpressionCompletion",
+ lv_inclusiveOrExpressionCompletion_1_0,
+ "InclusiveOrExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleInclusiveOrExpressionCompletion
+entryRuleInclusiveOrExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getInclusiveOrExpressionCompletionRule()); }
+ iv_ruleInclusiveOrExpressionCompletion=ruleInclusiveOrExpressionCompletion
+ { $current=$iv_ruleInclusiveOrExpressionCompletion.current; }
+ EOF
+;
+
+// Rule InclusiveOrExpressionCompletion
+ruleInclusiveOrExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getInclusiveOrExpressionCompletionAccess().getExclusiveOrExpressionCompletionExclusiveOrExpressionCompletionParserRuleCall_0_0());
+ }
+ lv_exclusiveOrExpressionCompletion_0_0=ruleExclusiveOrExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getInclusiveOrExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "exclusiveOrExpressionCompletion",
+ lv_exclusiveOrExpressionCompletion_0_0,
+ "ExclusiveOrExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1='|'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getInclusiveOrExpressionCompletionAccess().getVerticalLineKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getInclusiveOrExpressionCompletionAccess().getExclusiveOrExpressionExclusiveOrExpressionParserRuleCall_1_1_0());
+ }
+ lv_exclusiveOrExpression_2_0=ruleExclusiveOrExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getInclusiveOrExpressionCompletionRule());
+ }
+ add(
+ $current,
+ "exclusiveOrExpression",
+ lv_exclusiveOrExpression_2_0,
+ "ExclusiveOrExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleConditionalAndExpression
+entryRuleConditionalAndExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getConditionalAndExpressionRule()); }
+ iv_ruleConditionalAndExpression=ruleConditionalAndExpression
+ { $current=$iv_ruleConditionalAndExpression.current; }
+ EOF
+;
+
+// Rule ConditionalAndExpression
+ruleConditionalAndExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getConditionalAndExpressionAccess().getUnaryExpressionUnaryExpressionParserRuleCall_0_0());
+ }
+ lv_unaryExpression_0_0=ruleUnaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getConditionalAndExpressionRule());
+ }
+ set(
+ $current,
+ "unaryExpression",
+ lv_unaryExpression_0_0,
+ "UnaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getConditionalAndExpressionAccess().getConditionalAndExpressionCompletionConditionalAndExpressionCompletionParserRuleCall_1_0());
+ }
+ lv_conditionalAndExpressionCompletion_1_0=ruleConditionalAndExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getConditionalAndExpressionRule());
+ }
+ set(
+ $current,
+ "conditionalAndExpressionCompletion",
+ lv_conditionalAndExpressionCompletion_1_0,
+ "ConditionalAndExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleConditionalAndExpressionCompletion
+entryRuleConditionalAndExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getConditionalAndExpressionCompletionRule()); }
+ iv_ruleConditionalAndExpressionCompletion=ruleConditionalAndExpressionCompletion
+ { $current=$iv_ruleConditionalAndExpressionCompletion.current; }
+ EOF
+;
+
+// Rule ConditionalAndExpressionCompletion
+ruleConditionalAndExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getConditionalAndExpressionCompletionAccess().getInclusiveOrExpressionCompletionInclusiveOrExpressionCompletionParserRuleCall_0_0());
+ }
+ lv_inclusiveOrExpressionCompletion_0_0=ruleInclusiveOrExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getConditionalAndExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "inclusiveOrExpressionCompletion",
+ lv_inclusiveOrExpressionCompletion_0_0,
+ "InclusiveOrExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1='&&'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getConditionalAndExpressionCompletionAccess().getAmpersandAmpersandKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getConditionalAndExpressionCompletionAccess().getInclusiveOrExpressionInclusiveOrExpressionParserRuleCall_1_1_0());
+ }
+ lv_inclusiveOrExpression_2_0=ruleInclusiveOrExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getConditionalAndExpressionCompletionRule());
+ }
+ add(
+ $current,
+ "inclusiveOrExpression",
+ lv_inclusiveOrExpression_2_0,
+ "InclusiveOrExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+
+
+// Entry rule entryRuleConditionalOrExpressionCompletion
+entryRuleConditionalOrExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getConditionalOrExpressionCompletionRule()); }
+ iv_ruleConditionalOrExpressionCompletion=ruleConditionalOrExpressionCompletion
+ { $current=$iv_ruleConditionalOrExpressionCompletion.current; }
+ EOF
+;
+
+// Rule ConditionalOrExpressionCompletion
+ruleConditionalOrExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getConditionalOrExpressionCompletionAccess().getConditionalAndExpressionCompletionConditionalAndExpressionCompletionParserRuleCall_0_0());
+ }
+ lv_conditionalAndExpressionCompletion_0_0=ruleConditionalAndExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getConditionalOrExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "conditionalAndExpressionCompletion",
+ lv_conditionalAndExpressionCompletion_0_0,
+ "ConditionalAndExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1='||'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getConditionalOrExpressionCompletionAccess().getVerticalLineVerticalLineKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getConditionalOrExpressionCompletionAccess().getConditionalAndExpressionConditionalAndExpressionParserRuleCall_1_1_0());
+ }
+ lv_conditionalAndExpression_2_0=ruleConditionalAndExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getConditionalOrExpressionCompletionRule());
+ }
+ add(
+ $current,
+ "conditionalAndExpression",
+ lv_conditionalAndExpression_2_0,
+ "ConditionalAndExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleConditionalExpression
+entryRuleConditionalExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getConditionalExpressionRule()); }
+ iv_ruleConditionalExpression=ruleConditionalExpression
+ { $current=$iv_ruleConditionalExpression.current; }
+ EOF
+;
+
+// Rule ConditionalExpression
+ruleConditionalExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getConditionalExpressionAccess().getUnaryExpressionUnaryExpressionParserRuleCall_0_0());
+ }
+ lv_unaryExpression_0_0=ruleUnaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getConditionalExpressionRule());
+ }
+ set(
+ $current,
+ "unaryExpression",
+ lv_unaryExpression_0_0,
+ "UnaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getConditionalExpressionAccess().getConditionalExpressionCompletionConditionalExpressionCompletionParserRuleCall_1_0());
+ }
+ lv_conditionalExpressionCompletion_1_0=ruleConditionalExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getConditionalExpressionRule());
+ }
+ set(
+ $current,
+ "conditionalExpressionCompletion",
+ lv_conditionalExpressionCompletion_1_0,
+ "ConditionalExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleConditionalExpressionCompletion
+entryRuleConditionalExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getConditionalExpressionCompletionRule()); }
+ iv_ruleConditionalExpressionCompletion=ruleConditionalExpressionCompletion
+ { $current=$iv_ruleConditionalExpressionCompletion.current; }
+ EOF
+;
+
+// Rule ConditionalExpressionCompletion
+ruleConditionalExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getConditionalExpressionCompletionAccess().getConditionalOrExpressionCompletionConditionalOrExpressionCompletionParserRuleCall_0_0());
+ }
+ lv_conditionalOrExpressionCompletion_0_0=ruleConditionalOrExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getConditionalExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "conditionalOrExpressionCompletion",
+ lv_conditionalOrExpressionCompletion_0_0,
+ "ConditionalOrExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1='?'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getConditionalExpressionCompletionAccess().getQuestionMarkKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getConditionalExpressionCompletionAccess().getExpressionExpressionParserRuleCall_1_1_0());
+ }
+ lv_expression_2_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getConditionalExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_3=':'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getConditionalExpressionCompletionAccess().getColonKeyword_1_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getConditionalExpressionCompletionAccess().getConditionalExpressionConditionalExpressionParserRuleCall_1_3_0());
+ }
+ lv_conditionalExpression_4_0=ruleConditionalExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getConditionalExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "conditionalExpression",
+ lv_conditionalExpression_4_0,
+ "ConditionalExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleAssignmentExpressionCompletion
+entryRuleAssignmentExpressionCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssignmentExpressionCompletionRule()); }
+ iv_ruleAssignmentExpressionCompletion=ruleAssignmentExpressionCompletion
+ { $current=$iv_ruleAssignmentExpressionCompletion.current; }
+ EOF
+;
+
+// Rule AssignmentExpressionCompletion
+ruleAssignmentExpressionCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getAssignmentExpressionCompletionAccess().getOperatorAssignmentOperatorEnumRuleCall_0_0());
+ }
+ lv_operator_0_0=ruleAssignmentOperator {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignmentExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "operator",
+ lv_operator_0_0,
+ "AssignmentOperator");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getAssignmentExpressionCompletionAccess().getExpressionExpressionParserRuleCall_1_0());
+ }
+ lv_expression_1_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignmentExpressionCompletionRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleStatementSequence
+entryRuleStatementSequence returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getStatementSequenceRule()); }
+ iv_ruleStatementSequence=ruleStatementSequence
+ { $current=$iv_ruleStatementSequence.current; }
+ EOF
+;
+
+// Rule StatementSequence
+ruleStatementSequence returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getStatementSequenceAccess().getStatementSequenceAction_0(),
+ $current);
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getStatementSequenceAccess().getDocumentStatementDocumentedStatementParserRuleCall_1_0());
+ }
+ lv_documentStatement_1_0=ruleDocumentedStatement {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getStatementSequenceRule());
+ }
+ add(
+ $current,
+ "documentStatement",
+ lv_documentStatement_1_0,
+ "DocumentedStatement");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)*)
+;
+
+
+
+
+
+// Entry rule entryRuleDocumentedStatement
+entryRuleDocumentedStatement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getDocumentedStatementRule()); }
+ iv_ruleDocumentedStatement=ruleDocumentedStatement
+ { $current=$iv_ruleDocumentedStatement.current; }
+ EOF
+;
+
+// Rule DocumentedStatement
+ruleDocumentedStatement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_comment_0_0=RULE_ML_COMMENT
+ {
+ newLeafNode(lv_comment_0_0, grammarAccess.getDocumentedStatementAccess().getCommentML_COMMENTTerminalRuleCall_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getDocumentedStatementRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "comment",
+ lv_comment_0_0,
+ "ML_COMMENT");
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getDocumentedStatementAccess().getStatementStatementParserRuleCall_1_0());
+ }
+ lv_statement_1_0=ruleStatement {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDocumentedStatementRule());
+ }
+ set(
+ $current,
+ "statement",
+ lv_statement_1_0,
+ "Statement");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleStatement
+entryRuleStatement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getStatementRule()); }
+ iv_ruleStatement=ruleStatement
+ { $current=$iv_ruleStatement.current; }
+ EOF
+;
+
+// Rule Statement
+ruleStatement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getStatementAccess().getAnnotatedStatementParserRuleCall_0());
+ }
+ this_AnnotatedStatement_0=ruleAnnotatedStatement
+ {
+ $current = $this_AnnotatedStatement_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStatementAccess().getInLineStatementParserRuleCall_1());
+ }
+ this_InLineStatement_1=ruleInLineStatement
+ {
+ $current = $this_InLineStatement_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStatementAccess().getBlockStatementParserRuleCall_2());
+ }
+ this_BlockStatement_2=ruleBlockStatement
+ {
+ $current = $this_BlockStatement_2.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStatementAccess().getEmptyStatementParserRuleCall_3());
+ }
+ this_EmptyStatement_3=ruleEmptyStatement
+ {
+ $current = $this_EmptyStatement_3.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStatementAccess().getLocalNameDeclarationOrExpressionStatementParserRuleCall_4());
+ }
+ this_LocalNameDeclarationOrExpressionStatement_4=ruleLocalNameDeclarationOrExpressionStatement
+ {
+ $current = $this_LocalNameDeclarationOrExpressionStatement_4.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStatementAccess().getLocalNameDeclarationStatementParserRuleCall_5());
+ }
+ this_LocalNameDeclarationStatement_5=ruleLocalNameDeclarationStatement
+ {
+ $current = $this_LocalNameDeclarationStatement_5.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStatementAccess().getIfStatementParserRuleCall_6());
+ }
+ this_IfStatement_6=ruleIfStatement
+ {
+ $current = $this_IfStatement_6.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStatementAccess().getSwitchStatementParserRuleCall_7());
+ }
+ this_SwitchStatement_7=ruleSwitchStatement
+ {
+ $current = $this_SwitchStatement_7.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStatementAccess().getWhileStatementParserRuleCall_8());
+ }
+ this_WhileStatement_8=ruleWhileStatement
+ {
+ $current = $this_WhileStatement_8.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStatementAccess().getForStatementParserRuleCall_9());
+ }
+ this_ForStatement_9=ruleForStatement
+ {
+ $current = $this_ForStatement_9.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStatementAccess().getDoStatementParserRuleCall_10());
+ }
+ this_DoStatement_10=ruleDoStatement
+ {
+ $current = $this_DoStatement_10.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStatementAccess().getBreakStatementParserRuleCall_11());
+ }
+ this_BreakStatement_11=ruleBreakStatement
+ {
+ $current = $this_BreakStatement_11.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStatementAccess().getReturnStatementParserRuleCall_12());
+ }
+ this_ReturnStatement_12=ruleReturnStatement
+ {
+ $current = $this_ReturnStatement_12.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStatementAccess().getAcceptStatementParserRuleCall_13());
+ }
+ this_AcceptStatement_13=ruleAcceptStatement
+ {
+ $current = $this_AcceptStatement_13.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStatementAccess().getClassifyStatementParserRuleCall_14());
+ }
+ this_ClassifyStatement_14=ruleClassifyStatement
+ {
+ $current = $this_ClassifyStatement_14.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleBlock
+entryRuleBlock returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getBlockRule()); }
+ iv_ruleBlock=ruleBlock
+ { $current=$iv_ruleBlock.current; }
+ EOF
+;
+
+// Rule Block
+ruleBlock returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='{'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getBlockAccess().getLeftCurlyBracketKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getBlockAccess().getStatementSequenceStatementSequenceParserRuleCall_1_0());
+ }
+ lv_statementSequence_1_0=ruleStatementSequence {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getBlockRule());
+ }
+ set(
+ $current,
+ "statementSequence",
+ lv_statementSequence_1_0,
+ "StatementSequence");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_2='}'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getBlockAccess().getRightCurlyBracketKeyword_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleAnnotatedStatement
+entryRuleAnnotatedStatement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAnnotatedStatementRule()); }
+ iv_ruleAnnotatedStatement=ruleAnnotatedStatement
+ { $current=$iv_ruleAnnotatedStatement.current; }
+ EOF
+;
+
+// Rule AnnotatedStatement
+ruleAnnotatedStatement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='//@'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getAnnotatedStatementAccess().getSolidusSolidusCommercialAtKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getAnnotatedStatementAccess().getAnnotationsAnnotationsParserRuleCall_1_0());
+ }
+ lv_annotations_1_0=ruleAnnotations {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAnnotatedStatementRule());
+ }
+ set(
+ $current,
+ "annotations",
+ lv_annotations_1_0,
+ "Annotations");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_2='\n'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getAnnotatedStatementAccess().getControl000aKeyword_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getAnnotatedStatementAccess().getStatementStatementParserRuleCall_3_0());
+ }
+ lv_statement_3_0=ruleStatement {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAnnotatedStatementRule());
+ }
+ set(
+ $current,
+ "statement",
+ lv_statement_3_0,
+ "Statement");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleAnnotations
+entryRuleAnnotations returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAnnotationsRule()); }
+ iv_ruleAnnotations=ruleAnnotations
+ { $current=$iv_ruleAnnotations.current; }
+ EOF
+;
+
+// Rule Annotations
+ruleAnnotations returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getAnnotationsAccess().getAnnotationAnnotationParserRuleCall_0_0());
+ }
+ lv_annotation_0_0=ruleAnnotation {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAnnotationsRule());
+ }
+ add(
+ $current,
+ "annotation",
+ lv_annotation_0_0,
+ "Annotation");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1='@'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getAnnotationsAccess().getCommercialAtKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getAnnotationsAccess().getAnnotationAnnotationParserRuleCall_1_1_0());
+ }
+ lv_annotation_2_0=ruleAnnotation {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAnnotationsRule());
+ }
+ add(
+ $current,
+ "annotation",
+ lv_annotation_2_0,
+ "Annotation");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleAnnotation
+entryRuleAnnotation returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAnnotationRule()); }
+ iv_ruleAnnotation=ruleAnnotation
+ { $current=$iv_ruleAnnotation.current; }
+ EOF
+;
+
+// Rule Annotation
+ruleAnnotation returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_id_0_0=RULE_ID
+ {
+ newLeafNode(lv_id_0_0, grammarAccess.getAnnotationAccess().getIdIDTerminalRuleCall_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getAnnotationRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "id",
+ lv_id_0_0,
+ "ID");
+ }
+
+)
+)( otherlv_1='('
+ {
+ newLeafNode(otherlv_1, grammarAccess.getAnnotationAccess().getLeftParenthesisKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getAnnotationAccess().getNameListNameListParserRuleCall_1_1_0());
+ }
+ lv_nameList_2_0=ruleNameList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAnnotationRule());
+ }
+ set(
+ $current,
+ "nameList",
+ lv_nameList_2_0,
+ "NameList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_3=')'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getAnnotationAccess().getRightParenthesisKeyword_1_2());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleNameList
+entryRuleNameList returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNameListRule()); }
+ iv_ruleNameList=ruleNameList
+ { $current=$iv_ruleNameList.current; }
+ EOF
+;
+
+// Rule NameList
+ruleNameList returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getNameListAccess().getNameNameParserRuleCall_0_0());
+ }
+ lv_name_0_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNameListRule());
+ }
+ add(
+ $current,
+ "name",
+ lv_name_0_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=','
+ {
+ newLeafNode(otherlv_1, grammarAccess.getNameListAccess().getCommaKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getNameListAccess().getNameNameParserRuleCall_1_1_0());
+ }
+ lv_name_2_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNameListRule());
+ }
+ add(
+ $current,
+ "name",
+ lv_name_2_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleInLineStatement
+entryRuleInLineStatement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getInLineStatementRule()); }
+ iv_ruleInLineStatement=ruleInLineStatement
+ { $current=$iv_ruleInLineStatement.current; }
+ EOF
+;
+
+// Rule InLineStatement
+ruleInLineStatement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='/*@'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getInLineStatementAccess().getSolidusAsteriskCommercialAtKeyword_0());
+ }
+(
+(
+ lv_id_1_0=RULE_ID
+ {
+ newLeafNode(lv_id_1_0, grammarAccess.getInLineStatementAccess().getIdIDTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getInLineStatementRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "id",
+ lv_id_1_0,
+ "ID");
+ }
+
+)
+) otherlv_2='('
+ {
+ newLeafNode(otherlv_2, grammarAccess.getInLineStatementAccess().getLeftParenthesisKeyword_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getInLineStatementAccess().getNameNameParserRuleCall_3_0());
+ }
+ lv_name_3_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getInLineStatementRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_3_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_4=')'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getInLineStatementAccess().getRightParenthesisKeyword_4());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleBlockStatement
+entryRuleBlockStatement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getBlockStatementRule()); }
+ iv_ruleBlockStatement=ruleBlockStatement
+ { $current=$iv_ruleBlockStatement.current; }
+ EOF
+;
+
+// Rule BlockStatement
+ruleBlockStatement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ {
+ newCompositeNode(grammarAccess.getBlockStatementAccess().getBlockBlockParserRuleCall_0());
+ }
+ lv_block_0_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getBlockStatementRule());
+ }
+ set(
+ $current,
+ "block",
+ lv_block_0_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+;
+
+
+
+
+
+// Entry rule entryRuleEmptyStatement
+entryRuleEmptyStatement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getEmptyStatementRule()); }
+ iv_ruleEmptyStatement=ruleEmptyStatement
+ { $current=$iv_ruleEmptyStatement.current; }
+ EOF
+;
+
+// Rule EmptyStatement
+ruleEmptyStatement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getEmptyStatementAccess().getEmptyStatementAction_0(),
+ $current);
+ }
+) otherlv_1=';'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getEmptyStatementAccess().getSemicolonKeyword_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleLocalNameDeclarationOrExpressionStatement
+entryRuleLocalNameDeclarationOrExpressionStatement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getLocalNameDeclarationOrExpressionStatementRule()); }
+ iv_ruleLocalNameDeclarationOrExpressionStatement=ruleLocalNameDeclarationOrExpressionStatement
+ { $current=$iv_ruleLocalNameDeclarationOrExpressionStatement.current; }
+ EOF
+;
+
+// Rule LocalNameDeclarationOrExpressionStatement
+ruleLocalNameDeclarationOrExpressionStatement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+(
+ {
+ newCompositeNode(grammarAccess.getLocalNameDeclarationOrExpressionStatementAccess().getPotentiallyAmbiguousNameQualifiedNameParserRuleCall_0_0_0());
+ }
+ lv_potentiallyAmbiguousName_0_0=ruleQualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLocalNameDeclarationOrExpressionStatementRule());
+ }
+ set(
+ $current,
+ "potentiallyAmbiguousName",
+ lv_potentiallyAmbiguousName_0_0,
+ "QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(((
+(
+ {
+ newCompositeNode(grammarAccess.getLocalNameDeclarationOrExpressionStatementAccess().getMultiplicaityIndicatorMultiplicityIndicatorParserRuleCall_0_1_0_0_0());
+ }
+ lv_multiplicaityIndicator_1_0=ruleMultiplicityIndicator {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLocalNameDeclarationOrExpressionStatementRule());
+ }
+ set(
+ $current,
+ "multiplicaityIndicator",
+ lv_multiplicaityIndicator_1_0,
+ "MultiplicityIndicator");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getLocalNameDeclarationOrExpressionStatementAccess().getNameNameParserRuleCall_0_1_0_1_0());
+ }
+ lv_name_2_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLocalNameDeclarationOrExpressionStatementRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_2_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getLocalNameDeclarationOrExpressionStatementAccess().getLocalNameDeclarationCompletionLocalNameDeclarationStatementCompletionParserRuleCall_0_1_0_2_0());
+ }
+ lv_localNameDeclarationCompletion_3_0=ruleLocalNameDeclarationStatementCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLocalNameDeclarationOrExpressionStatementRule());
+ }
+ set(
+ $current,
+ "localNameDeclarationCompletion",
+ lv_localNameDeclarationCompletion_3_0,
+ "LocalNameDeclarationStatementCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |((
+(
+ {
+ newCompositeNode(grammarAccess.getLocalNameDeclarationOrExpressionStatementAccess().getNameToExpressionCompletionNameToExpressionCompletionParserRuleCall_0_1_1_0_0());
+ }
+ lv_nameToExpressionCompletion_4_0=ruleNameToExpressionCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLocalNameDeclarationOrExpressionStatementRule());
+ }
+ set(
+ $current,
+ "nameToExpressionCompletion",
+ lv_nameToExpressionCompletion_4_0,
+ "NameToExpressionCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_5=';'
+ {
+ newLeafNode(otherlv_5, grammarAccess.getLocalNameDeclarationOrExpressionStatementAccess().getSemicolonKeyword_0_1_1_1());
+ }
+)))
+ |((
+(
+ {
+ newCompositeNode(grammarAccess.getLocalNameDeclarationOrExpressionStatementAccess().getNonNameExpressionNonNameExpressionParserRuleCall_1_0_0());
+ }
+ lv_nonNameExpression_6_0=ruleNonNameExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLocalNameDeclarationOrExpressionStatementRule());
+ }
+ set(
+ $current,
+ "nonNameExpression",
+ lv_nonNameExpression_6_0,
+ "NonNameExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_7=';'
+ {
+ newLeafNode(otherlv_7, grammarAccess.getLocalNameDeclarationOrExpressionStatementAccess().getSemicolonKeyword_1_1());
+ }
+))
+;
+
+
+
+
+
+// Entry rule entryRuleLocalNameDeclarationStatement
+entryRuleLocalNameDeclarationStatement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getLocalNameDeclarationStatementRule()); }
+ iv_ruleLocalNameDeclarationStatement=ruleLocalNameDeclarationStatement
+ { $current=$iv_ruleLocalNameDeclarationStatement.current; }
+ EOF
+;
+
+// Rule LocalNameDeclarationStatement
+ruleLocalNameDeclarationStatement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='let'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getLocalNameDeclarationStatementAccess().getLetKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getLocalNameDeclarationStatementAccess().getNameNameParserRuleCall_1_0());
+ }
+ lv_name_1_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLocalNameDeclarationStatementRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_1_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_2=':'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getLocalNameDeclarationStatementAccess().getColonKeyword_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getLocalNameDeclarationStatementAccess().getTypeNameTypeNameParserRuleCall_3_0());
+ }
+ lv_typeName_3_0=ruleTypeName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLocalNameDeclarationStatementRule());
+ }
+ set(
+ $current,
+ "typeName",
+ lv_typeName_3_0,
+ "TypeName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorMultiplicityIndicatorParserRuleCall_4_0());
+ }
+ lv_multiplicityIndicator_4_0=ruleMultiplicityIndicator {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLocalNameDeclarationStatementRule());
+ }
+ set(
+ $current,
+ "multiplicityIndicator",
+ lv_multiplicityIndicator_4_0,
+ "MultiplicityIndicator");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getLocalNameDeclarationStatementAccess().getLocalNameDeclarationCompletionLocalNameDeclarationStatementCompletionParserRuleCall_5_0());
+ }
+ lv_localNameDeclarationCompletion_5_0=ruleLocalNameDeclarationStatementCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLocalNameDeclarationStatementRule());
+ }
+ set(
+ $current,
+ "localNameDeclarationCompletion",
+ lv_localNameDeclarationCompletion_5_0,
+ "LocalNameDeclarationStatementCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleLocalNameDeclarationStatementCompletion
+entryRuleLocalNameDeclarationStatementCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getLocalNameDeclarationStatementCompletionRule()); }
+ iv_ruleLocalNameDeclarationStatementCompletion=ruleLocalNameDeclarationStatementCompletion
+ { $current=$iv_ruleLocalNameDeclarationStatementCompletion.current; }
+ EOF
+;
+
+// Rule LocalNameDeclarationStatementCompletion
+ruleLocalNameDeclarationStatementCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='='
+ {
+ newLeafNode(otherlv_0, grammarAccess.getLocalNameDeclarationStatementCompletionAccess().getEqualsSignKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getLocalNameDeclarationStatementCompletionAccess().getInitializationExpressionInitializationExpressionParserRuleCall_1_0());
+ }
+ lv_initializationExpression_1_0=ruleInitializationExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLocalNameDeclarationStatementCompletionRule());
+ }
+ set(
+ $current,
+ "initializationExpression",
+ lv_initializationExpression_1_0,
+ "InitializationExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_2=';'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getLocalNameDeclarationStatementCompletionAccess().getSemicolonKeyword_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleInitializationExpression
+entryRuleInitializationExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getInitializationExpressionRule()); }
+ iv_ruleInitializationExpression=ruleInitializationExpression
+ { $current=$iv_ruleInitializationExpression.current; }
+ EOF
+;
+
+// Rule InitializationExpression
+ruleInitializationExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getInitializationExpressionAccess().getExpressionParserRuleCall_0());
+ }
+ this_Expression_0=ruleExpression
+ {
+ $current = $this_Expression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getInitializationExpressionAccess().getSequenceInitializationExpressionParserRuleCall_1());
+ }
+ this_SequenceInitializationExpression_1=ruleSequenceInitializationExpression
+ {
+ $current = $this_SequenceInitializationExpression_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getInitializationExpressionAccess().getInstanceInitializationExpressionParserRuleCall_2());
+ }
+ this_InstanceInitializationExpression_2=ruleInstanceInitializationExpression
+ {
+ $current = $this_InstanceInitializationExpression_2.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleInstanceInitializationExpression
+entryRuleInstanceInitializationExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getInstanceInitializationExpressionRule()); }
+ iv_ruleInstanceInitializationExpression=ruleInstanceInitializationExpression
+ { $current=$iv_ruleInstanceInitializationExpression.current; }
+ EOF
+;
+
+// Rule InstanceInitializationExpression
+ruleInstanceInitializationExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='new'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getInstanceInitializationExpressionAccess().getNewKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getInstanceInitializationExpressionAccess().getTupleTupleParserRuleCall_1_0());
+ }
+ lv_tuple_1_0=ruleTuple {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getInstanceInitializationExpressionRule());
+ }
+ set(
+ $current,
+ "tuple",
+ lv_tuple_1_0,
+ "Tuple");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleIfStatement
+entryRuleIfStatement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getIfStatementRule()); }
+ iv_ruleIfStatement=ruleIfStatement
+ { $current=$iv_ruleIfStatement.current; }
+ EOF
+;
+
+// Rule IfStatement
+ruleIfStatement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='if'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getIfStatementAccess().getIfKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getIfStatementAccess().getSequentialClausesSequentialClausesParserRuleCall_1_0());
+ }
+ lv_sequentialClauses_1_0=ruleSequentialClauses {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIfStatementRule());
+ }
+ set(
+ $current,
+ "sequentialClauses",
+ lv_sequentialClauses_1_0,
+ "SequentialClauses");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getIfStatementAccess().getFinalClauseFinalClauseParserRuleCall_2_0());
+ }
+ lv_finalClause_2_0=ruleFinalClause {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIfStatementRule());
+ }
+ set(
+ $current,
+ "finalClause",
+ lv_finalClause_2_0,
+ "FinalClause");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleSequentialClauses
+entryRuleSequentialClauses returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSequentialClausesRule()); }
+ iv_ruleSequentialClauses=ruleSequentialClauses
+ { $current=$iv_ruleSequentialClauses.current; }
+ EOF
+;
+
+// Rule SequentialClauses
+ruleSequentialClauses returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getSequentialClausesAccess().getConcurrentClausesConcurrentClausesParserRuleCall_0_0());
+ }
+ lv_concurrentClauses_0_0=ruleConcurrentClauses {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequentialClausesRule());
+ }
+ add(
+ $current,
+ "concurrentClauses",
+ lv_concurrentClauses_0_0,
+ "ConcurrentClauses");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1='else'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getSequentialClausesAccess().getElseKeyword_1_0());
+ }
+ otherlv_2='if'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getSequentialClausesAccess().getIfKeyword_1_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getSequentialClausesAccess().getConcurrentClausesConcurrentClausesParserRuleCall_1_2_0());
+ }
+ lv_concurrentClauses_3_0=ruleConcurrentClauses {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSequentialClausesRule());
+ }
+ add(
+ $current,
+ "concurrentClauses",
+ lv_concurrentClauses_3_0,
+ "ConcurrentClauses");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleConcurrentClauses
+entryRuleConcurrentClauses returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getConcurrentClausesRule()); }
+ iv_ruleConcurrentClauses=ruleConcurrentClauses
+ { $current=$iv_ruleConcurrentClauses.current; }
+ EOF
+;
+
+// Rule ConcurrentClauses
+ruleConcurrentClauses returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseNonFinalClauseParserRuleCall_0_0());
+ }
+ lv_nonFinalClause_0_0=ruleNonFinalClause {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getConcurrentClausesRule());
+ }
+ add(
+ $current,
+ "nonFinalClause",
+ lv_nonFinalClause_0_0,
+ "NonFinalClause");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1='or'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getConcurrentClausesAccess().getOrKeyword_1_0());
+ }
+ otherlv_2='if'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getConcurrentClausesAccess().getIfKeyword_1_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseNonFinalClauseParserRuleCall_1_2_0());
+ }
+ lv_nonFinalClause_3_0=ruleNonFinalClause {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getConcurrentClausesRule());
+ }
+ add(
+ $current,
+ "nonFinalClause",
+ lv_nonFinalClause_3_0,
+ "NonFinalClause");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleNonFinalClause
+entryRuleNonFinalClause returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNonFinalClauseRule()); }
+ iv_ruleNonFinalClause=ruleNonFinalClause
+ { $current=$iv_ruleNonFinalClause.current; }
+ EOF
+;
+
+// Rule NonFinalClause
+ruleNonFinalClause returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='('
+ {
+ newLeafNode(otherlv_0, grammarAccess.getNonFinalClauseAccess().getLeftParenthesisKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getNonFinalClauseAccess().getExpressionExpressionParserRuleCall_1_0());
+ }
+ lv_expression_1_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNonFinalClauseRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_2=')'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getNonFinalClauseAccess().getRightParenthesisKeyword_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getNonFinalClauseAccess().getBlockBlockParserRuleCall_3_0());
+ }
+ lv_block_3_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNonFinalClauseRule());
+ }
+ set(
+ $current,
+ "block",
+ lv_block_3_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleFinalClause
+entryRuleFinalClause returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getFinalClauseRule()); }
+ iv_ruleFinalClause=ruleFinalClause
+ { $current=$iv_ruleFinalClause.current; }
+ EOF
+;
+
+// Rule FinalClause
+ruleFinalClause returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='else'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getFinalClauseAccess().getElseKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getFinalClauseAccess().getBlockBlockParserRuleCall_1_0());
+ }
+ lv_block_1_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFinalClauseRule());
+ }
+ set(
+ $current,
+ "block",
+ lv_block_1_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleSwitchStatement
+entryRuleSwitchStatement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSwitchStatementRule()); }
+ iv_ruleSwitchStatement=ruleSwitchStatement
+ { $current=$iv_ruleSwitchStatement.current; }
+ EOF
+;
+
+// Rule SwitchStatement
+ruleSwitchStatement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='switch'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getSwitchStatementAccess().getSwitchKeyword_0());
+ }
+ otherlv_1='('
+ {
+ newLeafNode(otherlv_1, grammarAccess.getSwitchStatementAccess().getLeftParenthesisKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getSwitchStatementAccess().getExpressionExpressionParserRuleCall_2_0());
+ }
+ lv_expression_2_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSwitchStatementRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_3=')'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getSwitchStatementAccess().getRightParenthesisKeyword_3());
+ }
+ otherlv_4='{'
+ {
+ newLeafNode(otherlv_4, grammarAccess.getSwitchStatementAccess().getLeftCurlyBracketKeyword_4());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getSwitchStatementAccess().getSwitchClauseSwitchClauseParserRuleCall_5_0());
+ }
+ lv_switchClause_5_0=ruleSwitchClause {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSwitchStatementRule());
+ }
+ add(
+ $current,
+ "switchClause",
+ lv_switchClause_5_0,
+ "SwitchClause");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)*(
+(
+ {
+ newCompositeNode(grammarAccess.getSwitchStatementAccess().getDefaultClauseSwitchDefaultClauseParserRuleCall_6_0());
+ }
+ lv_defaultClause_6_0=ruleSwitchDefaultClause {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSwitchStatementRule());
+ }
+ set(
+ $current,
+ "defaultClause",
+ lv_defaultClause_6_0,
+ "SwitchDefaultClause");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)? otherlv_7='}'
+ {
+ newLeafNode(otherlv_7, grammarAccess.getSwitchStatementAccess().getRightCurlyBracketKeyword_7());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleSwitchClause
+entryRuleSwitchClause returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSwitchClauseRule()); }
+ iv_ruleSwitchClause=ruleSwitchClause
+ { $current=$iv_ruleSwitchClause.current; }
+ EOF
+;
+
+// Rule SwitchClause
+ruleSwitchClause returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getSwitchClauseAccess().getSwitchCaseSwitchCaseParserRuleCall_0_0());
+ }
+ lv_switchCase_0_0=ruleSwitchCase {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSwitchClauseRule());
+ }
+ add(
+ $current,
+ "switchCase",
+ lv_switchCase_0_0,
+ "SwitchCase");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getSwitchClauseAccess().getSwitchCaseSwitchCaseParserRuleCall_1_0());
+ }
+ lv_switchCase_1_0=ruleSwitchCase {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSwitchClauseRule());
+ }
+ add(
+ $current,
+ "switchCase",
+ lv_switchCase_1_0,
+ "SwitchCase");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)*(
+(
+ {
+ newCompositeNode(grammarAccess.getSwitchClauseAccess().getStatementSequenceNonEmptyStatementSequenceParserRuleCall_2_0());
+ }
+ lv_statementSequence_2_0=ruleNonEmptyStatementSequence {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSwitchClauseRule());
+ }
+ set(
+ $current,
+ "statementSequence",
+ lv_statementSequence_2_0,
+ "NonEmptyStatementSequence");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleSwitchCase
+entryRuleSwitchCase returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSwitchCaseRule()); }
+ iv_ruleSwitchCase=ruleSwitchCase
+ { $current=$iv_ruleSwitchCase.current; }
+ EOF
+;
+
+// Rule SwitchCase
+ruleSwitchCase returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='case'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getSwitchCaseAccess().getCaseKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getSwitchCaseAccess().getExpressionExpressionParserRuleCall_1_0());
+ }
+ lv_expression_1_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSwitchCaseRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_2=':'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getSwitchCaseAccess().getColonKeyword_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleSwitchDefaultClause
+entryRuleSwitchDefaultClause returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSwitchDefaultClauseRule()); }
+ iv_ruleSwitchDefaultClause=ruleSwitchDefaultClause
+ { $current=$iv_ruleSwitchDefaultClause.current; }
+ EOF
+;
+
+// Rule SwitchDefaultClause
+ruleSwitchDefaultClause returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='default'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getSwitchDefaultClauseAccess().getDefaultKeyword_0());
+ }
+ otherlv_1=':'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getSwitchDefaultClauseAccess().getColonKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getSwitchDefaultClauseAccess().getStatementSequenceNonEmptyStatementSequenceParserRuleCall_2_0());
+ }
+ lv_statementSequence_2_0=ruleNonEmptyStatementSequence {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSwitchDefaultClauseRule());
+ }
+ set(
+ $current,
+ "statementSequence",
+ lv_statementSequence_2_0,
+ "NonEmptyStatementSequence");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleNonEmptyStatementSequence
+entryRuleNonEmptyStatementSequence returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNonEmptyStatementSequenceRule()); }
+ iv_ruleNonEmptyStatementSequence=ruleNonEmptyStatementSequence
+ { $current=$iv_ruleNonEmptyStatementSequence.current; }
+ EOF
+;
+
+// Rule NonEmptyStatementSequence
+ruleNonEmptyStatementSequence returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ {
+ newCompositeNode(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementDocumentedStatementParserRuleCall_0());
+ }
+ lv_statement_0_0=ruleDocumentedStatement {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNonEmptyStatementSequenceRule());
+ }
+ add(
+ $current,
+ "statement",
+ lv_statement_0_0,
+ "DocumentedStatement");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)+
+;
+
+
+
+
+
+// Entry rule entryRuleWhileStatement
+entryRuleWhileStatement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getWhileStatementRule()); }
+ iv_ruleWhileStatement=ruleWhileStatement
+ { $current=$iv_ruleWhileStatement.current; }
+ EOF
+;
+
+// Rule WhileStatement
+ruleWhileStatement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='while'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getWhileStatementAccess().getWhileKeyword_0());
+ }
+ otherlv_1='('
+ {
+ newLeafNode(otherlv_1, grammarAccess.getWhileStatementAccess().getLeftParenthesisKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getWhileStatementAccess().getExpressionExpressionParserRuleCall_2_0());
+ }
+ lv_expression_2_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getWhileStatementRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_3=')'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getWhileStatementAccess().getRightParenthesisKeyword_3());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getWhileStatementAccess().getBlockBlockParserRuleCall_4_0());
+ }
+ lv_block_4_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getWhileStatementRule());
+ }
+ set(
+ $current,
+ "block",
+ lv_block_4_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleDoStatement
+entryRuleDoStatement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getDoStatementRule()); }
+ iv_ruleDoStatement=ruleDoStatement
+ { $current=$iv_ruleDoStatement.current; }
+ EOF
+;
+
+// Rule DoStatement
+ruleDoStatement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='do'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getDoStatementAccess().getDoKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getDoStatementAccess().getBlockBlockParserRuleCall_1_0());
+ }
+ lv_block_1_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDoStatementRule());
+ }
+ set(
+ $current,
+ "block",
+ lv_block_1_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_2='while'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getDoStatementAccess().getWhileKeyword_2());
+ }
+ otherlv_3='('
+ {
+ newLeafNode(otherlv_3, grammarAccess.getDoStatementAccess().getLeftParenthesisKeyword_3());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getDoStatementAccess().getExpressionExpressionParserRuleCall_4_0());
+ }
+ lv_expression_4_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDoStatementRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_5=')'
+ {
+ newLeafNode(otherlv_5, grammarAccess.getDoStatementAccess().getRightParenthesisKeyword_5());
+ }
+ otherlv_6=';'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getDoStatementAccess().getSemicolonKeyword_6());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleForStatement
+entryRuleForStatement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getForStatementRule()); }
+ iv_ruleForStatement=ruleForStatement
+ { $current=$iv_ruleForStatement.current; }
+ EOF
+;
+
+// Rule ForStatement
+ruleForStatement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='for'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getForStatementAccess().getForKeyword_0());
+ }
+ otherlv_1='('
+ {
+ newLeafNode(otherlv_1, grammarAccess.getForStatementAccess().getLeftParenthesisKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getForStatementAccess().getForControlForControlParserRuleCall_2_0());
+ }
+ lv_forControl_2_0=ruleForControl {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForStatementRule());
+ }
+ set(
+ $current,
+ "forControl",
+ lv_forControl_2_0,
+ "ForControl");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_3=')'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getForStatementAccess().getRightParenthesisKeyword_3());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getForStatementAccess().getBlockBlockParserRuleCall_4_0());
+ }
+ lv_block_4_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForStatementRule());
+ }
+ set(
+ $current,
+ "block",
+ lv_block_4_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleForControl
+entryRuleForControl returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getForControlRule()); }
+ iv_ruleForControl=ruleForControl
+ { $current=$iv_ruleForControl.current; }
+ EOF
+;
+
+// Rule ForControl
+ruleForControl returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getForControlAccess().getLoopVariableDefinitionLoopVariableDefinitionParserRuleCall_0_0());
+ }
+ lv_loopVariableDefinition_0_0=ruleLoopVariableDefinition {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForControlRule());
+ }
+ add(
+ $current,
+ "loopVariableDefinition",
+ lv_loopVariableDefinition_0_0,
+ "LoopVariableDefinition");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=','
+ {
+ newLeafNode(otherlv_1, grammarAccess.getForControlAccess().getCommaKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getForControlAccess().getLoopVariableDefinitionLoopVariableDefinitionParserRuleCall_1_1_0());
+ }
+ lv_loopVariableDefinition_2_0=ruleLoopVariableDefinition {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForControlRule());
+ }
+ add(
+ $current,
+ "loopVariableDefinition",
+ lv_loopVariableDefinition_2_0,
+ "LoopVariableDefinition");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleLoopVariableDefinition
+entryRuleLoopVariableDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getLoopVariableDefinitionRule()); }
+ iv_ruleLoopVariableDefinition=ruleLoopVariableDefinition
+ { $current=$iv_ruleLoopVariableDefinition.current; }
+ EOF
+;
+
+// Rule LoopVariableDefinition
+ruleLoopVariableDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+(
+ {
+ newCompositeNode(grammarAccess.getLoopVariableDefinitionAccess().getNameNameParserRuleCall_0_0_0());
+ }
+ lv_name_0_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLoopVariableDefinitionRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_0_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_1='in'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getLoopVariableDefinitionAccess().getInKeyword_0_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getLoopVariableDefinitionAccess().getExpression1ExpressionParserRuleCall_0_2_0());
+ }
+ lv_expression1_2_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLoopVariableDefinitionRule());
+ }
+ set(
+ $current,
+ "expression1",
+ lv_expression1_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_3='..'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getLoopVariableDefinitionAccess().getFullStopFullStopKeyword_0_3_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getLoopVariableDefinitionAccess().getExpression2ExpressionParserRuleCall_0_3_1_0());
+ }
+ lv_expression2_4_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLoopVariableDefinitionRule());
+ }
+ set(
+ $current,
+ "expression2",
+ lv_expression2_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+ |((
+(
+ {
+ newCompositeNode(grammarAccess.getLoopVariableDefinitionAccess().getTypeNameQualifiedNameParserRuleCall_1_0_0());
+ }
+ lv_typeName_5_0=ruleQualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLoopVariableDefinitionRule());
+ }
+ set(
+ $current,
+ "typeName",
+ lv_typeName_5_0,
+ "QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getLoopVariableDefinitionAccess().getNameNameParserRuleCall_1_1_0());
+ }
+ lv_name_6_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLoopVariableDefinitionRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_6_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_7=':'
+ {
+ newLeafNode(otherlv_7, grammarAccess.getLoopVariableDefinitionAccess().getColonKeyword_1_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getLoopVariableDefinitionAccess().getExpression3ExpressionParserRuleCall_1_3_0());
+ }
+ lv_expression3_8_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLoopVariableDefinitionRule());
+ }
+ set(
+ $current,
+ "expression3",
+ lv_expression3_8_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+;
+
+
+
+
+
+// Entry rule entryRuleBreakStatement
+entryRuleBreakStatement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getBreakStatementRule()); }
+ iv_ruleBreakStatement=ruleBreakStatement
+ { $current=$iv_ruleBreakStatement.current; }
+ EOF
+;
+
+// Rule BreakStatement
+ruleBreakStatement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getBreakStatementAccess().getBreakStatementAction_0(),
+ $current);
+ }
+) otherlv_1='break'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getBreakStatementAccess().getBreakKeyword_1());
+ }
+ otherlv_2=';'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getBreakStatementAccess().getSemicolonKeyword_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleReturnStatement
+entryRuleReturnStatement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getReturnStatementRule()); }
+ iv_ruleReturnStatement=ruleReturnStatement
+ { $current=$iv_ruleReturnStatement.current; }
+ EOF
+;
+
+// Rule ReturnStatement
+ruleReturnStatement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getReturnStatementAccess().getReturnStatementAction_0(),
+ $current);
+ }
+) otherlv_1='return'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getReturnStatementAccess().getReturnKeyword_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getReturnStatementAccess().getExpressionExpressionParserRuleCall_2_0());
+ }
+ lv_expression_2_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getReturnStatementRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)? otherlv_3=';'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getReturnStatementAccess().getSemicolonKeyword_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleAcceptStatement
+entryRuleAcceptStatement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAcceptStatementRule()); }
+ iv_ruleAcceptStatement=ruleAcceptStatement
+ { $current=$iv_ruleAcceptStatement.current; }
+ EOF
+;
+
+// Rule AcceptStatement
+ruleAcceptStatement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getAcceptStatementAccess().getAcceptClauseAcceptClauseParserRuleCall_0_0());
+ }
+ lv_acceptClause_0_0=ruleAcceptClause {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAcceptStatementRule());
+ }
+ set(
+ $current,
+ "acceptClause",
+ lv_acceptClause_0_0,
+ "AcceptClause");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((
+(
+ {
+ newCompositeNode(grammarAccess.getAcceptStatementAccess().getSimpleCompletionSimpleAcceptStatementCompletionParserRuleCall_1_0_0());
+ }
+ lv_simpleCompletion_1_0=ruleSimpleAcceptStatementCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAcceptStatementRule());
+ }
+ set(
+ $current,
+ "simpleCompletion",
+ lv_simpleCompletion_1_0,
+ "SimpleAcceptStatementCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getAcceptStatementAccess().getCompoundCompletionCompoundAcceptStatementCompletionParserRuleCall_1_1_0());
+ }
+ lv_compoundCompletion_2_0=ruleCompoundAcceptStatementCompletion {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAcceptStatementRule());
+ }
+ set(
+ $current,
+ "compoundCompletion",
+ lv_compoundCompletion_2_0,
+ "CompoundAcceptStatementCompletion");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+;
+
+
+
+
+
+// Entry rule entryRuleSimpleAcceptStatementCompletion
+entryRuleSimpleAcceptStatementCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSimpleAcceptStatementCompletionRule()); }
+ iv_ruleSimpleAcceptStatementCompletion=ruleSimpleAcceptStatementCompletion
+ { $current=$iv_ruleSimpleAcceptStatementCompletion.current; }
+ EOF
+;
+
+// Rule SimpleAcceptStatementCompletion
+ruleSimpleAcceptStatementCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getSimpleAcceptStatementCompletionAccess().getSimpleAcceptStatementCompletionAction_0(),
+ $current);
+ }
+) otherlv_1=';'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getSimpleAcceptStatementCompletionAccess().getSemicolonKeyword_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleCompoundAcceptStatementCompletion
+entryRuleCompoundAcceptStatementCompletion returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getCompoundAcceptStatementCompletionRule()); }
+ iv_ruleCompoundAcceptStatementCompletion=ruleCompoundAcceptStatementCompletion
+ { $current=$iv_ruleCompoundAcceptStatementCompletion.current; }
+ EOF
+;
+
+// Rule CompoundAcceptStatementCompletion
+ruleCompoundAcceptStatementCompletion returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getCompoundAcceptStatementCompletionAccess().getBlockBlockParserRuleCall_0_0());
+ }
+ lv_block_0_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getCompoundAcceptStatementCompletionRule());
+ }
+ set(
+ $current,
+ "block",
+ lv_block_0_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1='or'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getCompoundAcceptStatementCompletionAccess().getOrKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getCompoundAcceptStatementCompletionAccess().getAcceptBlockAcceptBlockParserRuleCall_1_1_0());
+ }
+ lv_acceptBlock_2_0=ruleAcceptBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getCompoundAcceptStatementCompletionRule());
+ }
+ add(
+ $current,
+ "acceptBlock",
+ lv_acceptBlock_2_0,
+ "AcceptBlock");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleAcceptBlock
+entryRuleAcceptBlock returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAcceptBlockRule()); }
+ iv_ruleAcceptBlock=ruleAcceptBlock
+ { $current=$iv_ruleAcceptBlock.current; }
+ EOF
+;
+
+// Rule AcceptBlock
+ruleAcceptBlock returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getAcceptBlockAccess().getAcceptClauseAcceptClauseParserRuleCall_0_0());
+ }
+ lv_acceptClause_0_0=ruleAcceptClause {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAcceptBlockRule());
+ }
+ set(
+ $current,
+ "acceptClause",
+ lv_acceptClause_0_0,
+ "AcceptClause");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getAcceptBlockAccess().getBlockBlockParserRuleCall_1_0());
+ }
+ lv_block_1_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAcceptBlockRule());
+ }
+ set(
+ $current,
+ "block",
+ lv_block_1_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleAcceptClause
+entryRuleAcceptClause returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAcceptClauseRule()); }
+ iv_ruleAcceptClause=ruleAcceptClause
+ { $current=$iv_ruleAcceptClause.current; }
+ EOF
+;
+
+// Rule AcceptClause
+ruleAcceptClause returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='accept'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getAcceptClauseAccess().getAcceptKeyword_0());
+ }
+ otherlv_1='('
+ {
+ newLeafNode(otherlv_1, grammarAccess.getAcceptClauseAccess().getLeftParenthesisKeyword_1());
+ }
+((
+(
+ {
+ newCompositeNode(grammarAccess.getAcceptClauseAccess().getNameNameParserRuleCall_2_0_0());
+ }
+ lv_name_2_0=ruleName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAcceptClauseRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_2_0,
+ "Name");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_3=':'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getAcceptClauseAccess().getColonKeyword_2_1());
+ }
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getAcceptClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_3_0());
+ }
+ lv_qualifiedNameList_4_0=ruleQualifiedNameList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAcceptClauseRule());
+ }
+ set(
+ $current,
+ "qualifiedNameList",
+ lv_qualifiedNameList_4_0,
+ "QualifiedNameList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_5=')'
+ {
+ newLeafNode(otherlv_5, grammarAccess.getAcceptClauseAccess().getRightParenthesisKeyword_4());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleClassifyStatement
+entryRuleClassifyStatement returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassifyStatementRule()); }
+ iv_ruleClassifyStatement=ruleClassifyStatement
+ { $current=$iv_ruleClassifyStatement.current; }
+ EOF
+;
+
+// Rule ClassifyStatement
+ruleClassifyStatement returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='classify'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getClassifyStatementAccess().getClassifyKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getClassifyStatementAccess().getExpressionExpressionParserRuleCall_1_0());
+ }
+ lv_expression_1_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassifyStatementRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getClassifyStatementAccess().getClassificationClauseClassificationClauseParserRuleCall_2_0());
+ }
+ lv_classificationClause_2_0=ruleClassificationClause {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassifyStatementRule());
+ }
+ set(
+ $current,
+ "classificationClause",
+ lv_classificationClause_2_0,
+ "ClassificationClause");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_3=';'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getClassifyStatementAccess().getSemicolonKeyword_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleClassificationClause
+entryRuleClassificationClause returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassificationClauseRule()); }
+ iv_ruleClassificationClause=ruleClassificationClause
+ { $current=$iv_ruleClassificationClause.current; }
+ EOF
+;
+
+// Rule ClassificationClause
+ruleClassificationClause returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+(
+ {
+ newCompositeNode(grammarAccess.getClassificationClauseAccess().getClassificationFromClauseClassificationFromClauseParserRuleCall_0_0_0());
+ }
+ lv_classificationFromClause_0_0=ruleClassificationFromClause {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassificationClauseRule());
+ }
+ set(
+ $current,
+ "classificationFromClause",
+ lv_classificationFromClause_0_0,
+ "ClassificationFromClause");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getClassificationClauseAccess().getClassificationToClauseClassificationToClauseParserRuleCall_0_1_0());
+ }
+ lv_classificationToClause_1_0=ruleClassificationToClause {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassificationClauseRule());
+ }
+ set(
+ $current,
+ "classificationToClause",
+ lv_classificationToClause_1_0,
+ "ClassificationToClause");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+ |((
+(
+ {
+ newCompositeNode(grammarAccess.getClassificationClauseAccess().getReclassifyAllClauseReclassifyAllClauseParserRuleCall_1_0_0());
+ }
+ lv_reclassifyAllClause_2_0=ruleReclassifyAllClause {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassificationClauseRule());
+ }
+ set(
+ $current,
+ "reclassifyAllClause",
+ lv_reclassifyAllClause_2_0,
+ "ReclassifyAllClause");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getClassificationClauseAccess().getClassificationToClauseClassificationToClauseParserRuleCall_1_1_0());
+ }
+ lv_classificationToClause_3_0=ruleClassificationToClause {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassificationClauseRule());
+ }
+ set(
+ $current,
+ "classificationToClause",
+ lv_classificationToClause_3_0,
+ "ClassificationToClause");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+;
+
+
+
+
+
+// Entry rule entryRuleClassificationFromClause
+entryRuleClassificationFromClause returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassificationFromClauseRule()); }
+ iv_ruleClassificationFromClause=ruleClassificationFromClause
+ { $current=$iv_ruleClassificationFromClause.current; }
+ EOF
+;
+
+// Rule ClassificationFromClause
+ruleClassificationFromClause returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='from'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getClassificationFromClauseAccess().getFromKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getClassificationFromClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_1_0());
+ }
+ lv_qualifiedNameList_1_0=ruleQualifiedNameList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassificationFromClauseRule());
+ }
+ set(
+ $current,
+ "qualifiedNameList",
+ lv_qualifiedNameList_1_0,
+ "QualifiedNameList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleClassificationToClause
+entryRuleClassificationToClause returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassificationToClauseRule()); }
+ iv_ruleClassificationToClause=ruleClassificationToClause
+ { $current=$iv_ruleClassificationToClause.current; }
+ EOF
+;
+
+// Rule ClassificationToClause
+ruleClassificationToClause returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='to'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getClassificationToClauseAccess().getToKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getClassificationToClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_1_0());
+ }
+ lv_qualifiedNameList_1_0=ruleQualifiedNameList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassificationToClauseRule());
+ }
+ set(
+ $current,
+ "qualifiedNameList",
+ lv_qualifiedNameList_1_0,
+ "QualifiedNameList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleReclassifyAllClause
+entryRuleReclassifyAllClause returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getReclassifyAllClauseRule()); }
+ iv_ruleReclassifyAllClause=ruleReclassifyAllClause
+ { $current=$iv_ruleReclassifyAllClause.current; }
+ EOF
+;
+
+// Rule ReclassifyAllClause
+ruleReclassifyAllClause returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getReclassifyAllClauseAccess().getReclassifyAllClauseAction_0(),
+ $current);
+ }
+) otherlv_1='from'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getReclassifyAllClauseAccess().getFromKeyword_1());
+ }
+ otherlv_2='*'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getReclassifyAllClauseAccess().getAsteriskKeyword_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleQualifiedNameList
+entryRuleQualifiedNameList returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getQualifiedNameListRule()); }
+ iv_ruleQualifiedNameList=ruleQualifiedNameList
+ { $current=$iv_ruleQualifiedNameList.current; }
+ EOF
+;
+
+// Rule QualifiedNameList
+ruleQualifiedNameList returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getQualifiedNameListAccess().getQualifiedNameQualifiedNameParserRuleCall_0_0());
+ }
+ lv_qualifiedName_0_0=ruleQualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getQualifiedNameListRule());
+ }
+ add(
+ $current,
+ "qualifiedName",
+ lv_qualifiedName_0_0,
+ "QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1=','
+ {
+ newLeafNode(otherlv_1, grammarAccess.getQualifiedNameListAccess().getCommaKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getQualifiedNameListAccess().getQualifiedNameQualifiedNameParserRuleCall_1_1_0());
+ }
+ lv_qualifiedName_2_0=ruleQualifiedName {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getQualifiedNameListRule());
+ }
+ add(
+ $current,
+ "qualifiedName",
+ lv_qualifiedName_2_0,
+ "QualifiedName");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Rule ImportVisibilityIndicator
+ruleImportVisibilityIndicator returns [Enumerator current=null]
+ @init { enterRule(); }
+ @after { leaveRule(); }:
+(( enumLiteral_0='public'
+ {
+ $current = grammarAccess.getImportVisibilityIndicatorAccess().getPUBLICEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_0, grammarAccess.getImportVisibilityIndicatorAccess().getPUBLICEnumLiteralDeclaration_0());
+ }
+)
+ |( enumLiteral_1='private'
+ {
+ $current = grammarAccess.getImportVisibilityIndicatorAccess().getPRIVATEEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_1, grammarAccess.getImportVisibilityIndicatorAccess().getPRIVATEEnumLiteralDeclaration_1());
+ }
+));
+
+
+
+// Rule ParameterDirection
+ruleParameterDirection returns [Enumerator current=null]
+ @init { enterRule(); }
+ @after { leaveRule(); }:
+(( enumLiteral_0='in'
+ {
+ $current = grammarAccess.getParameterDirectionAccess().getINEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_0, grammarAccess.getParameterDirectionAccess().getINEnumLiteralDeclaration_0());
+ }
+)
+ |( enumLiteral_1='out'
+ {
+ $current = grammarAccess.getParameterDirectionAccess().getOUTEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_1, grammarAccess.getParameterDirectionAccess().getOUTEnumLiteralDeclaration_1());
+ }
+)
+ |( enumLiteral_2='inout'
+ {
+ $current = grammarAccess.getParameterDirectionAccess().getINOUTEnumLiteralDeclaration_2().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_2, grammarAccess.getParameterDirectionAccess().getINOUTEnumLiteralDeclaration_2());
+ }
+));
+
+
+
+// Rule LinkOperation
+ruleLinkOperation returns [Enumerator current=null]
+ @init { enterRule(); }
+ @after { leaveRule(); }:
+(( enumLiteral_0='createLink'
+ {
+ $current = grammarAccess.getLinkOperationAccess().getCREATE_LINKEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_0, grammarAccess.getLinkOperationAccess().getCREATE_LINKEnumLiteralDeclaration_0());
+ }
+)
+ |( enumLiteral_1='destroyLink'
+ {
+ $current = grammarAccess.getLinkOperationAccess().getDESTROY_LINKEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_1, grammarAccess.getLinkOperationAccess().getDESTROY_LINKEnumLiteralDeclaration_1());
+ }
+)
+ |( enumLiteral_2='clearAssoc'
+ {
+ $current = grammarAccess.getLinkOperationAccess().getCLEAR_ASSOCEnumLiteralDeclaration_2().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_2, grammarAccess.getLinkOperationAccess().getCLEAR_ASSOCEnumLiteralDeclaration_2());
+ }
+));
+
+
+
+// Rule AffixOperator
+ruleAffixOperator returns [Enumerator current=null]
+ @init { enterRule(); }
+ @after { leaveRule(); }:
+(( enumLiteral_0='++'
+ {
+ $current = grammarAccess.getAffixOperatorAccess().getINCREnumLiteralDeclaration_0().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_0, grammarAccess.getAffixOperatorAccess().getINCREnumLiteralDeclaration_0());
+ }
+)
+ |( enumLiteral_1='--'
+ {
+ $current = grammarAccess.getAffixOperatorAccess().getDECREnumLiteralDeclaration_1().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_1, grammarAccess.getAffixOperatorAccess().getDECREnumLiteralDeclaration_1());
+ }
+));
+
+
+
+// Rule NumericUnaryOperator
+ruleNumericUnaryOperator returns [Enumerator current=null]
+ @init { enterRule(); }
+ @after { leaveRule(); }:
+(( enumLiteral_0='+'
+ {
+ $current = grammarAccess.getNumericUnaryOperatorAccess().getPLUSEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_0, grammarAccess.getNumericUnaryOperatorAccess().getPLUSEnumLiteralDeclaration_0());
+ }
+)
+ |( enumLiteral_1='-'
+ {
+ $current = grammarAccess.getNumericUnaryOperatorAccess().getMINUSEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_1, grammarAccess.getNumericUnaryOperatorAccess().getMINUSEnumLiteralDeclaration_1());
+ }
+));
+
+
+
+// Rule MultiplicativeOperator
+ruleMultiplicativeOperator returns [Enumerator current=null]
+ @init { enterRule(); }
+ @after { leaveRule(); }:
+(( enumLiteral_0='*'
+ {
+ $current = grammarAccess.getMultiplicativeOperatorAccess().getSTAREnumLiteralDeclaration_0().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_0, grammarAccess.getMultiplicativeOperatorAccess().getSTAREnumLiteralDeclaration_0());
+ }
+)
+ |( enumLiteral_1='/'
+ {
+ $current = grammarAccess.getMultiplicativeOperatorAccess().getSLASHEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_1, grammarAccess.getMultiplicativeOperatorAccess().getSLASHEnumLiteralDeclaration_1());
+ }
+)
+ |( enumLiteral_2='%'
+ {
+ $current = grammarAccess.getMultiplicativeOperatorAccess().getREMEnumLiteralDeclaration_2().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_2, grammarAccess.getMultiplicativeOperatorAccess().getREMEnumLiteralDeclaration_2());
+ }
+));
+
+
+
+// Rule AdditiveOperator
+ruleAdditiveOperator returns [Enumerator current=null]
+ @init { enterRule(); }
+ @after { leaveRule(); }:
+(( enumLiteral_0='+'
+ {
+ $current = grammarAccess.getAdditiveOperatorAccess().getPLUSEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_0, grammarAccess.getAdditiveOperatorAccess().getPLUSEnumLiteralDeclaration_0());
+ }
+)
+ |( enumLiteral_1='-'
+ {
+ $current = grammarAccess.getAdditiveOperatorAccess().getMINUSEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_1, grammarAccess.getAdditiveOperatorAccess().getMINUSEnumLiteralDeclaration_1());
+ }
+));
+
+
+
+// Rule ShiftOperator
+ruleShiftOperator returns [Enumerator current=null]
+ @init { enterRule(); }
+ @after { leaveRule(); }:
+(( enumLiteral_0='<<'
+ {
+ $current = grammarAccess.getShiftOperatorAccess().getLSHIFTEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_0, grammarAccess.getShiftOperatorAccess().getLSHIFTEnumLiteralDeclaration_0());
+ }
+)
+ |( enumLiteral_1='>>'
+ {
+ $current = grammarAccess.getShiftOperatorAccess().getRSHIFTEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_1, grammarAccess.getShiftOperatorAccess().getRSHIFTEnumLiteralDeclaration_1());
+ }
+)
+ |( enumLiteral_2='>>>'
+ {
+ $current = grammarAccess.getShiftOperatorAccess().getURSHIFTEnumLiteralDeclaration_2().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_2, grammarAccess.getShiftOperatorAccess().getURSHIFTEnumLiteralDeclaration_2());
+ }
+));
+
+
+
+// Rule RelationalOperator
+ruleRelationalOperator returns [Enumerator current=null]
+ @init { enterRule(); }
+ @after { leaveRule(); }:
+(( enumLiteral_0='<'
+ {
+ $current = grammarAccess.getRelationalOperatorAccess().getLTEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_0, grammarAccess.getRelationalOperatorAccess().getLTEnumLiteralDeclaration_0());
+ }
+)
+ |( enumLiteral_1='>'
+ {
+ $current = grammarAccess.getRelationalOperatorAccess().getGTEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_1, grammarAccess.getRelationalOperatorAccess().getGTEnumLiteralDeclaration_1());
+ }
+)
+ |( enumLiteral_2='<='
+ {
+ $current = grammarAccess.getRelationalOperatorAccess().getLEEnumLiteralDeclaration_2().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_2, grammarAccess.getRelationalOperatorAccess().getLEEnumLiteralDeclaration_2());
+ }
+)
+ |( enumLiteral_3='>='
+ {
+ $current = grammarAccess.getRelationalOperatorAccess().getGEEnumLiteralDeclaration_3().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_3, grammarAccess.getRelationalOperatorAccess().getGEEnumLiteralDeclaration_3());
+ }
+));
+
+
+
+// Rule ClassificationOperator
+ruleClassificationOperator returns [Enumerator current=null]
+ @init { enterRule(); }
+ @after { leaveRule(); }:
+(( enumLiteral_0='instanceof'
+ {
+ $current = grammarAccess.getClassificationOperatorAccess().getINSTANCEOFEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_0, grammarAccess.getClassificationOperatorAccess().getINSTANCEOFEnumLiteralDeclaration_0());
+ }
+)
+ |( enumLiteral_1='hastype'
+ {
+ $current = grammarAccess.getClassificationOperatorAccess().getHASTYPEEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_1, grammarAccess.getClassificationOperatorAccess().getHASTYPEEnumLiteralDeclaration_1());
+ }
+));
+
+
+
+// Rule EqualityOperator
+ruleEqualityOperator returns [Enumerator current=null]
+ @init { enterRule(); }
+ @after { leaveRule(); }:
+(( enumLiteral_0='=='
+ {
+ $current = grammarAccess.getEqualityOperatorAccess().getEQEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_0, grammarAccess.getEqualityOperatorAccess().getEQEnumLiteralDeclaration_0());
+ }
+)
+ |( enumLiteral_1='!='
+ {
+ $current = grammarAccess.getEqualityOperatorAccess().getNEEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_1, grammarAccess.getEqualityOperatorAccess().getNEEnumLiteralDeclaration_1());
+ }
+));
+
+
+
+// Rule AssignmentOperator
+ruleAssignmentOperator returns [Enumerator current=null]
+ @init { enterRule(); }
+ @after { leaveRule(); }:
+(( enumLiteral_0='='
+ {
+ $current = grammarAccess.getAssignmentOperatorAccess().getASSIGNEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_0, grammarAccess.getAssignmentOperatorAccess().getASSIGNEnumLiteralDeclaration_0());
+ }
+)
+ |( enumLiteral_1='+='
+ {
+ $current = grammarAccess.getAssignmentOperatorAccess().getPLUSASSIGNEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_1, grammarAccess.getAssignmentOperatorAccess().getPLUSASSIGNEnumLiteralDeclaration_1());
+ }
+)
+ |( enumLiteral_2='-='
+ {
+ $current = grammarAccess.getAssignmentOperatorAccess().getMINUSASSIGNEnumLiteralDeclaration_2().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_2, grammarAccess.getAssignmentOperatorAccess().getMINUSASSIGNEnumLiteralDeclaration_2());
+ }
+)
+ |( enumLiteral_3='*='
+ {
+ $current = grammarAccess.getAssignmentOperatorAccess().getSTARASSIGNEnumLiteralDeclaration_3().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_3, grammarAccess.getAssignmentOperatorAccess().getSTARASSIGNEnumLiteralDeclaration_3());
+ }
+)
+ |( enumLiteral_4='/='
+ {
+ $current = grammarAccess.getAssignmentOperatorAccess().getSLASHASSIGNEnumLiteralDeclaration_4().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_4, grammarAccess.getAssignmentOperatorAccess().getSLASHASSIGNEnumLiteralDeclaration_4());
+ }
+)
+ |( enumLiteral_5='%='
+ {
+ $current = grammarAccess.getAssignmentOperatorAccess().getREMASSIGNEnumLiteralDeclaration_5().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_5, grammarAccess.getAssignmentOperatorAccess().getREMASSIGNEnumLiteralDeclaration_5());
+ }
+)
+ |( enumLiteral_6='&='
+ {
+ $current = grammarAccess.getAssignmentOperatorAccess().getANSASSIGNEnumLiteralDeclaration_6().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_6, grammarAccess.getAssignmentOperatorAccess().getANSASSIGNEnumLiteralDeclaration_6());
+ }
+)
+ |( enumLiteral_7='|='
+ {
+ $current = grammarAccess.getAssignmentOperatorAccess().getORASSIGNEnumLiteralDeclaration_7().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_7, grammarAccess.getAssignmentOperatorAccess().getORASSIGNEnumLiteralDeclaration_7());
+ }
+)
+ |( enumLiteral_8='^='
+ {
+ $current = grammarAccess.getAssignmentOperatorAccess().getXORASSIGNEnumLiteralDeclaration_8().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_8, grammarAccess.getAssignmentOperatorAccess().getXORASSIGNEnumLiteralDeclaration_8());
+ }
+)
+ |( enumLiteral_9='<<='
+ {
+ $current = grammarAccess.getAssignmentOperatorAccess().getLSHIFTASSIGNEnumLiteralDeclaration_9().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_9, grammarAccess.getAssignmentOperatorAccess().getLSHIFTASSIGNEnumLiteralDeclaration_9());
+ }
+)
+ |( enumLiteral_10='>>='
+ {
+ $current = grammarAccess.getAssignmentOperatorAccess().getRSHIFTASSIGNEnumLiteralDeclaration_10().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_10, grammarAccess.getAssignmentOperatorAccess().getRSHIFTASSIGNEnumLiteralDeclaration_10());
+ }
+)
+ |( enumLiteral_11='>>>='
+ {
+ $current = grammarAccess.getAssignmentOperatorAccess().getURSHIFTASSIGNEnumLiteralDeclaration_11().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_11, grammarAccess.getAssignmentOperatorAccess().getURSHIFTASSIGNEnumLiteralDeclaration_11());
+ }
+));
+
+
+
+RULE_BOOLEAN_VALUE : ('true'|'false');
+
+RULE_INTEGER_VALUE : (('0'|'1'..'9' ('_'? '0'..'9')*)|('0b'|'0B') '0'..'1' ('_'? '0'..'1')*|('0x'|'0X') ('0'..'9'|'a'..'f'|'A'..'F') ('_'? ('0'..'9'|'a'..'f'|'A'..'F'))*|'0' '_'? '0'..'7' ('_'? '0'..'7')*);
+
+RULE_ID : (('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*|'\'' ( options {greedy=false;} : . )*'\'');
+
+RULE_STRING : '"' ('\\' ('b'|'t'|'n'|'f'|'r'|'"'|'\''|'\\')|~(('\\'|'"')))* '"';
+
+RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/';
+
+RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?;
+
+RULE_INT : ('0'..'9')+;
+
+RULE_WS : (' '|'\t'|'\r'|'\n')+;
+
+RULE_ANY_OTHER : .;
+
+

Back to the top