/*
 * generated by Xtext
 */
grammar InternalEditor;

options {
	superClass=AbstractInternalAntlrParser;
	
}

@lexer::header {
package org.opendaylight.nemo.tool.eclipse.plugin.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.opendaylight.nemo.tool.eclipse.plugin.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.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.opendaylight.nemo.tool.eclipse.plugin.services.EditorGrammarAccess;

}

@parser::members {

 	private EditorGrammarAccess grammarAccess;
 	
    public InternalEditorParser(TokenStream input, EditorGrammarAccess grammarAccess) {
        this(input);
        this.grammarAccess = grammarAccess;
        registerRules(grammarAccess.getGrammar());
    }
    
    @Override
    protected String getFirstRuleName() {
    	return "Model";	
   	}
   	
   	@Override
   	protected EditorGrammarAccess getGrammarAccess() {
   		return grammarAccess;
   	}
}

@rulecatch { 
    catch (RecognitionException re) { 
        recover(input,re); 
        appendSkippedTokens();
    } 
}




// Entry rule entryRuleModel
entryRuleModel returns [EObject current=null] 
	:
	{ newCompositeNode(grammarAccess.getModelRule()); }
	 iv_ruleModel=ruleModel 
	 { $current=$iv_ruleModel.current; } 
	 EOF 
;

// Rule Model
ruleModel returns [EObject current=null] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
(
(
		{ 
	        newCompositeNode(grammarAccess.getModelAccess().getSentencesSentenceParserRuleCall_0()); 
	    }
		lv_sentences_0_0=ruleSentence		{
	        if ($current==null) {
	            $current = createModelElementForParent(grammarAccess.getModelRule());
	        }
       		add(
       			$current, 
       			"sentences",
        		lv_sentences_0_0, 
        		"Sentence");
	        afterParserOrEnumRuleCall();
	    }

)
)*
;





// Entry rule entryRuleSentence
entryRuleSentence returns [EObject current=null] 
	:
	{ newCompositeNode(grammarAccess.getSentenceRule()); }
	 iv_ruleSentence=ruleSentence 
	 { $current=$iv_ruleSentence.current; } 
	 EOF 
;

// Rule Sentence
ruleSentence returns [EObject current=null] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
(
    { 
        newCompositeNode(grammarAccess.getSentenceAccess().getSenEnginesParserRuleCall_0()); 
    }
ruleSenEngines
    { 
        afterParserOrEnumRuleCall();
    }

    |
    { 
        newCompositeNode(grammarAccess.getSentenceAccess().getUserParserRuleCall_1()); 
    }
ruleUser
    { 
        afterParserOrEnumRuleCall();
    }

    |
    { 
        newCompositeNode(grammarAccess.getSentenceAccess().getNodeParserRuleCall_2()); 
    }
    this_Node_2=ruleNode
    { 
        $current = $this_Node_2.current; 
        afterParserOrEnumRuleCall();
    }

    |
    { 
        newCompositeNode(grammarAccess.getSentenceAccess().getNodeOperatingParserRuleCall_3()); 
    }
    this_NodeOperating_3=ruleNodeOperating
    { 
        $current = $this_NodeOperating_3.current; 
        afterParserOrEnumRuleCall();
    }

    |
    { 
        newCompositeNode(grammarAccess.getSentenceAccess().getConnectionParserRuleCall_4()); 
    }
    this_Connection_4=ruleConnection
    { 
        $current = $this_Connection_4.current; 
        afterParserOrEnumRuleCall();
    }

    |
    { 
        newCompositeNode(grammarAccess.getSentenceAccess().getConnectionUpdateParserRuleCall_5()); 
    }
    this_ConnectionUpdate_5=ruleConnectionUpdate
    { 
        $current = $this_ConnectionUpdate_5.current; 
        afterParserOrEnumRuleCall();
    }

    |
    { 
        newCompositeNode(grammarAccess.getSentenceAccess().getFlowParserRuleCall_6()); 
    }
    this_Flow_6=ruleFlow
    { 
        $current = $this_Flow_6.current; 
        afterParserOrEnumRuleCall();
    }

    |
    { 
        newCompositeNode(grammarAccess.getSentenceAccess().getFlowUpdateParserRuleCall_7()); 
    }
    this_FlowUpdate_7=ruleFlowUpdate
    { 
        $current = $this_FlowUpdate_7.current; 
        afterParserOrEnumRuleCall();
    }

    |
    { 
        newCompositeNode(grammarAccess.getSentenceAccess().getOperationParserRuleCall_8()); 
    }
    this_Operation_8=ruleOperation
    { 
        $current = $this_Operation_8.current; 
        afterParserOrEnumRuleCall();
    }
)
;





// Entry rule entryRuleSenEngines
entryRuleSenEngines returns [String current=null] 
	:
	{ newCompositeNode(grammarAccess.getSenEnginesRule()); } 
	 iv_ruleSenEngines=ruleSenEngines 
	 { $current=$iv_ruleSenEngines.current.getText(); }  
	 EOF 
;

// Rule SenEngines
ruleSenEngines returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
(
	kw='Engines:' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getSenEnginesAccess().getEnginesKeyword_0()); 
    }

    { 
        newCompositeNode(grammarAccess.getSenEnginesAccess().getIpv4ParserRuleCall_1()); 
    }
    this_Ipv4_1=ruleIpv4    {
		$current.merge(this_Ipv4_1);
    }

    { 
        afterParserOrEnumRuleCall();
    }
(
	kw=',' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getSenEnginesAccess().getCommaKeyword_2_0()); 
    }

    { 
        newCompositeNode(grammarAccess.getSenEnginesAccess().getIpv4ParserRuleCall_2_1()); 
    }
    this_Ipv4_3=ruleIpv4    {
		$current.merge(this_Ipv4_3);
    }

    { 
        afterParserOrEnumRuleCall();
    }
)*
	kw=';' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getSenEnginesAccess().getSemicolonKeyword_3()); 
    }
)
    ;





// Entry rule entryRuleIpv4
entryRuleIpv4 returns [String current=null] 
	:
	{ newCompositeNode(grammarAccess.getIpv4Rule()); } 
	 iv_ruleIpv4=ruleIpv4 
	 { $current=$iv_ruleIpv4.current.getText(); }  
	 EOF 
;

// Rule Ipv4
ruleIpv4 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
(    this_IPV4_SUB_0=RULE_IPV4_SUB    {
		$current.merge(this_IPV4_SUB_0);
    }

    { 
    newLeafNode(this_IPV4_SUB_0, grammarAccess.getIpv4Access().getIPV4_SUBTerminalRuleCall_0()); 
    }

	kw='.' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getIpv4Access().getFullStopKeyword_1()); 
    }
    this_IPV4_SUB_2=RULE_IPV4_SUB    {
		$current.merge(this_IPV4_SUB_2);
    }

    { 
    newLeafNode(this_IPV4_SUB_2, grammarAccess.getIpv4Access().getIPV4_SUBTerminalRuleCall_2()); 
    }

	kw='.' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getIpv4Access().getFullStopKeyword_3()); 
    }
    this_IPV4_SUB_4=RULE_IPV4_SUB    {
		$current.merge(this_IPV4_SUB_4);
    }

    { 
    newLeafNode(this_IPV4_SUB_4, grammarAccess.getIpv4Access().getIPV4_SUBTerminalRuleCall_4()); 
    }

	kw='.' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getIpv4Access().getFullStopKeyword_5()); 
    }
    this_IPV4_SUB_6=RULE_IPV4_SUB    {
		$current.merge(this_IPV4_SUB_6);
    }

    { 
    newLeafNode(this_IPV4_SUB_6, grammarAccess.getIpv4Access().getIPV4_SUBTerminalRuleCall_6()); 
    }
)
    ;





// Entry rule entryRuleUser
entryRuleUser returns [String current=null] 
	:
	{ newCompositeNode(grammarAccess.getUserRule()); } 
	 iv_ruleUser=ruleUser 
	 { $current=$iv_ruleUser.current.getText(); }  
	 EOF 
;

// Rule User
ruleUser returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
(
	kw='CREATE' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getUserAccess().getCREATEKeyword_0()); 
    }
    this_STRING_1=RULE_STRING    {
		$current.merge(this_STRING_1);
    }

    { 
    newLeafNode(this_STRING_1, grammarAccess.getUserAccess().getSTRINGTerminalRuleCall_1()); 
    }
    this_STRING_2=RULE_STRING    {
		$current.merge(this_STRING_2);
    }

    { 
    newLeafNode(this_STRING_2, grammarAccess.getUserAccess().getSTRINGTerminalRuleCall_2()); 
    }
    this_STRING_3=RULE_STRING    {
		$current.merge(this_STRING_3);
    }

    { 
    newLeafNode(this_STRING_3, grammarAccess.getUserAccess().getSTRINGTerminalRuleCall_3()); 
    }

	kw=';' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getUserAccess().getSemicolonKeyword_4()); 
    }
)
    ;





// Entry rule entryRuleNode
entryRuleNode returns [EObject current=null] 
	:
	{ newCompositeNode(grammarAccess.getNodeRule()); }
	 iv_ruleNode=ruleNode 
	 { $current=$iv_ruleNode.current; } 
	 EOF 
;

// Rule Node
ruleNode returns [EObject current=null] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
(
    { 
        newCompositeNode(grammarAccess.getNodeAccess().getNewObjParserRuleCall_0()); 
    }
ruleNewObj
    { 
        afterParserOrEnumRuleCall();
    }
	otherlv_1='Node' 
    {
    	newLeafNode(otherlv_1, grammarAccess.getNodeAccess().getNodeKeyword_1());
    }
(
(
		lv_name_2_0=RULE_NEMOID
		{
			newLeafNode(lv_name_2_0, grammarAccess.getNodeAccess().getNameNemoIdTerminalRuleCall_2_0()); 
		}
		{
	        if ($current==null) {
	            $current = createModelElement(grammarAccess.getNodeRule());
	        }
       		setWithLastConsumed(
       			$current, 
       			"name",
        		lv_name_2_0, 
        		"NemoId");
	    }

)
)(	otherlv_3='Type' 
    {
    	newLeafNode(otherlv_3, grammarAccess.getNodeAccess().getTypeKeyword_3_0());
    }
this_NemoId_4=RULE_NEMOID
    { 
    newLeafNode(this_NemoId_4, grammarAccess.getNodeAccess().getNemoIdTerminalRuleCall_3_1()); 
    }
)(	otherlv_5='Contain' 
    {
    	newLeafNode(otherlv_5, grammarAccess.getNodeAccess().getContainKeyword_4_0());
    }
(
(
		{
			if ($current==null) {
	            $current = createModelElement(grammarAccess.getNodeRule());
	        }
        }
	otherlv_6=RULE_NEMOID
	{
		newLeafNode(otherlv_6, grammarAccess.getNodeAccess().getNodesNodeCrossReference_4_1_0()); 
	}

)
)(	otherlv_7=',' 
    {
    	newLeafNode(otherlv_7, grammarAccess.getNodeAccess().getCommaKeyword_4_2_0());
    }
(
(
		{
			if ($current==null) {
	            $current = createModelElement(grammarAccess.getNodeRule());
	        }
        }
	otherlv_8=RULE_NEMOID
	{
		newLeafNode(otherlv_8, grammarAccess.getNodeAccess().getNodesNodeCrossReference_4_2_1_0()); 
	}

)
))*)?(
    { 
        newCompositeNode(grammarAccess.getNodeAccess().getPropertyParserRuleCall_5()); 
    }
ruleProperty
    { 
        afterParserOrEnumRuleCall();
    }
)?	otherlv_10=';' 
    {
    	newLeafNode(otherlv_10, grammarAccess.getNodeAccess().getSemicolonKeyword_6());
    }
)
;







// Entry rule entryRuleNodeOperating
entryRuleNodeOperating returns [EObject current=null] 
	:
	{ newCompositeNode(grammarAccess.getNodeOperatingRule()); }
	 iv_ruleNodeOperating=ruleNodeOperating 
	 { $current=$iv_ruleNodeOperating.current; } 
	 EOF 
;

// Rule NodeOperating
ruleNodeOperating returns [EObject current=null] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
((	otherlv_0='UPDATE' 
    {
    	newLeafNode(otherlv_0, grammarAccess.getNodeOperatingAccess().getUPDATEKeyword_0_0());
    }

    |	otherlv_1='DELETE' 
    {
    	newLeafNode(otherlv_1, grammarAccess.getNodeOperatingAccess().getDELETEKeyword_0_1());
    }
)	otherlv_2='Node' 
    {
    	newLeafNode(otherlv_2, grammarAccess.getNodeOperatingAccess().getNodeKeyword_1());
    }
(
(
		{
			if ($current==null) {
	            $current = createModelElement(grammarAccess.getNodeOperatingRule());
	        }
        }
	otherlv_3=RULE_NEMOID
	{
		newLeafNode(otherlv_3, grammarAccess.getNodeOperatingAccess().getNodenameNodeCrossReference_2_0()); 
	}

)
)(	otherlv_4='Type' 
    {
    	newLeafNode(otherlv_4, grammarAccess.getNodeOperatingAccess().getTypeKeyword_3_0());
    }
this_NemoId_5=RULE_NEMOID
    { 
    newLeafNode(this_NemoId_5, grammarAccess.getNodeOperatingAccess().getNemoIdTerminalRuleCall_3_1()); 
    }
)?(	otherlv_6='Contain' 
    {
    	newLeafNode(otherlv_6, grammarAccess.getNodeOperatingAccess().getContainKeyword_4_0());
    }
(
(
		{
			if ($current==null) {
	            $current = createModelElement(grammarAccess.getNodeOperatingRule());
	        }
        }
	otherlv_7=RULE_NEMOID
	{
		newLeafNode(otherlv_7, grammarAccess.getNodeOperatingAccess().getNodesNodeCrossReference_4_1_0()); 
	}

)
)(	otherlv_8=',' 
    {
    	newLeafNode(otherlv_8, grammarAccess.getNodeOperatingAccess().getCommaKeyword_4_2_0());
    }
(
(
		{
			if ($current==null) {
	            $current = createModelElement(grammarAccess.getNodeOperatingRule());
	        }
        }
	otherlv_9=RULE_NEMOID
	{
		newLeafNode(otherlv_9, grammarAccess.getNodeOperatingAccess().getNodesNodeCrossReference_4_2_1_0()); 
	}

)
))*)?(
    { 
        newCompositeNode(grammarAccess.getNodeOperatingAccess().getPropertyParserRuleCall_5()); 
    }
ruleProperty
    { 
        afterParserOrEnumRuleCall();
    }
)?	otherlv_11=';' 
    {
    	newLeafNode(otherlv_11, grammarAccess.getNodeOperatingAccess().getSemicolonKeyword_6());
    }
)
;





// Entry rule entryRuleConnection
entryRuleConnection returns [EObject current=null] 
	:
	{ newCompositeNode(grammarAccess.getConnectionRule()); }
	 iv_ruleConnection=ruleConnection 
	 { $current=$iv_ruleConnection.current; } 
	 EOF 
;

// Rule Connection
ruleConnection returns [EObject current=null] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
(	otherlv_0='CREATE' 
    {
    	newLeafNode(otherlv_0, grammarAccess.getConnectionAccess().getCREATEKeyword_0());
    }
	otherlv_1='Connection' 
    {
    	newLeafNode(otherlv_1, grammarAccess.getConnectionAccess().getConnectionKeyword_1());
    }
(
(
		lv_name_2_0=RULE_NEMOID
		{
			newLeafNode(lv_name_2_0, grammarAccess.getConnectionAccess().getNameNemoIdTerminalRuleCall_2_0()); 
		}
		{
	        if ($current==null) {
	            $current = createModelElement(grammarAccess.getConnectionRule());
	        }
       		setWithLastConsumed(
       			$current, 
       			"name",
        		lv_name_2_0, 
        		"NemoId");
	    }

)
)	otherlv_3='Type' 
    {
    	newLeafNode(otherlv_3, grammarAccess.getConnectionAccess().getTypeKeyword_3());
    }
this_NemoId_4=RULE_NEMOID
    { 
    newLeafNode(this_NemoId_4, grammarAccess.getConnectionAccess().getNemoIdTerminalRuleCall_4()); 
    }
(	otherlv_5='Endnodes' 
    {
    	newLeafNode(otherlv_5, grammarAccess.getConnectionAccess().getEndnodesKeyword_5_0());
    }
(
(
		{
			if ($current==null) {
	            $current = createModelElement(grammarAccess.getConnectionRule());
	        }
        }
	otherlv_6=RULE_NEMOID
	{
		newLeafNode(otherlv_6, grammarAccess.getConnectionAccess().getEndnodeNodeCrossReference_5_1_0()); 
	}

)
)(	otherlv_7=',' 
    {
    	newLeafNode(otherlv_7, grammarAccess.getConnectionAccess().getCommaKeyword_5_2_0());
    }
(
(
		{
			if ($current==null) {
	            $current = createModelElement(grammarAccess.getConnectionRule());
	        }
        }
	otherlv_8=RULE_NEMOID
	{
		newLeafNode(otherlv_8, grammarAccess.getConnectionAccess().getEndnodeNodeCrossReference_5_2_1_0()); 
	}

)
))*)(
    { 
        newCompositeNode(grammarAccess.getConnectionAccess().getPropertyParserRuleCall_6()); 
    }
ruleProperty
    { 
        afterParserOrEnumRuleCall();
    }
)?	otherlv_10=';' 
    {
    	newLeafNode(otherlv_10, grammarAccess.getConnectionAccess().getSemicolonKeyword_7());
    }
)
;





// Entry rule entryRuleConnectionUpdate
entryRuleConnectionUpdate returns [EObject current=null] 
	:
	{ newCompositeNode(grammarAccess.getConnectionUpdateRule()); }
	 iv_ruleConnectionUpdate=ruleConnectionUpdate 
	 { $current=$iv_ruleConnectionUpdate.current; } 
	 EOF 
;

// Rule ConnectionUpdate
ruleConnectionUpdate returns [EObject current=null] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
((	otherlv_0='UPDATE' 
    {
    	newLeafNode(otherlv_0, grammarAccess.getConnectionUpdateAccess().getUPDATEKeyword_0_0());
    }

    |	otherlv_1='DELETE' 
    {
    	newLeafNode(otherlv_1, grammarAccess.getConnectionUpdateAccess().getDELETEKeyword_0_1());
    }
)	otherlv_2='Connection' 
    {
    	newLeafNode(otherlv_2, grammarAccess.getConnectionUpdateAccess().getConnectionKeyword_1());
    }
(
(
		{
			if ($current==null) {
	            $current = createModelElement(grammarAccess.getConnectionUpdateRule());
	        }
        }
	otherlv_3=RULE_NEMOID
	{
		newLeafNode(otherlv_3, grammarAccess.getConnectionUpdateAccess().getConnectionnameConnectionCrossReference_2_0()); 
	}

)
)(	otherlv_4='Type' 
    {
    	newLeafNode(otherlv_4, grammarAccess.getConnectionUpdateAccess().getTypeKeyword_3_0());
    }
this_NemoId_5=RULE_NEMOID
    { 
    newLeafNode(this_NemoId_5, grammarAccess.getConnectionUpdateAccess().getNemoIdTerminalRuleCall_3_1()); 
    }
)?(	otherlv_6='Endnodes' 
    {
    	newLeafNode(otherlv_6, grammarAccess.getConnectionUpdateAccess().getEndnodesKeyword_4_0());
    }
(
(
		{
			if ($current==null) {
	            $current = createModelElement(grammarAccess.getConnectionUpdateRule());
	        }
        }
	otherlv_7=RULE_NEMOID
	{
		newLeafNode(otherlv_7, grammarAccess.getConnectionUpdateAccess().getEndnodeNodeCrossReference_4_1_0()); 
	}

)
)(	otherlv_8=',' 
    {
    	newLeafNode(otherlv_8, grammarAccess.getConnectionUpdateAccess().getCommaKeyword_4_2_0());
    }
(
(
		{
			if ($current==null) {
	            $current = createModelElement(grammarAccess.getConnectionUpdateRule());
	        }
        }
	otherlv_9=RULE_NEMOID
	{
		newLeafNode(otherlv_9, grammarAccess.getConnectionUpdateAccess().getEndnodeNodeCrossReference_4_2_1_0()); 
	}

)
))*)?(
    { 
        newCompositeNode(grammarAccess.getConnectionUpdateAccess().getPropertyParserRuleCall_5()); 
    }
ruleProperty
    { 
        afterParserOrEnumRuleCall();
    }
)?	otherlv_11=';' 
    {
    	newLeafNode(otherlv_11, grammarAccess.getConnectionUpdateAccess().getSemicolonKeyword_6());
    }
)
;





// Entry rule entryRuleFlow
entryRuleFlow returns [EObject current=null] 
	:
	{ newCompositeNode(grammarAccess.getFlowRule()); }
	 iv_ruleFlow=ruleFlow 
	 { $current=$iv_ruleFlow.current; } 
	 EOF 
;

// Rule Flow
ruleFlow returns [EObject current=null] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
(	otherlv_0='CREATE' 
    {
    	newLeafNode(otherlv_0, grammarAccess.getFlowAccess().getCREATEKeyword_0());
    }
	otherlv_1='Flow' 
    {
    	newLeafNode(otherlv_1, grammarAccess.getFlowAccess().getFlowKeyword_1());
    }
(
(
		lv_name_2_0=RULE_NEMOID
		{
			newLeafNode(lv_name_2_0, grammarAccess.getFlowAccess().getNameNemoIdTerminalRuleCall_2_0()); 
		}
		{
	        if ($current==null) {
	            $current = createModelElement(grammarAccess.getFlowRule());
	        }
       		setWithLastConsumed(
       			$current, 
       			"name",
        		lv_name_2_0, 
        		"NemoId");
	    }

)
)(
    { 
        newCompositeNode(grammarAccess.getFlowAccess().getMatchesParserRuleCall_3()); 
    }
ruleMatches
    { 
        afterParserOrEnumRuleCall();
    }
)?	otherlv_4=';' 
    {
    	newLeafNode(otherlv_4, grammarAccess.getFlowAccess().getSemicolonKeyword_4());
    }
)
;





// Entry rule entryRuleFlowUpdate
entryRuleFlowUpdate returns [EObject current=null] 
	:
	{ newCompositeNode(grammarAccess.getFlowUpdateRule()); }
	 iv_ruleFlowUpdate=ruleFlowUpdate 
	 { $current=$iv_ruleFlowUpdate.current; } 
	 EOF 
;

// Rule FlowUpdate
ruleFlowUpdate returns [EObject current=null] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
((	otherlv_0='UPDATE' 
    {
    	newLeafNode(otherlv_0, grammarAccess.getFlowUpdateAccess().getUPDATEKeyword_0_0());
    }

    |	otherlv_1='DELETE' 
    {
    	newLeafNode(otherlv_1, grammarAccess.getFlowUpdateAccess().getDELETEKeyword_0_1());
    }
)	otherlv_2='Flow' 
    {
    	newLeafNode(otherlv_2, grammarAccess.getFlowUpdateAccess().getFlowKeyword_1());
    }
(
(
		{
			if ($current==null) {
	            $current = createModelElement(grammarAccess.getFlowUpdateRule());
	        }
        }
	otherlv_3=RULE_NEMOID
	{
		newLeafNode(otherlv_3, grammarAccess.getFlowUpdateAccess().getFlowIdFlowCrossReference_2_0()); 
	}

)
)(
    { 
        newCompositeNode(grammarAccess.getFlowUpdateAccess().getMatchesParserRuleCall_3()); 
    }
ruleMatches
    { 
        afterParserOrEnumRuleCall();
    }
)?	otherlv_5=';' 
    {
    	newLeafNode(otherlv_5, grammarAccess.getFlowUpdateAccess().getSemicolonKeyword_4());
    }
)
;





// Entry rule entryRuleMatches
entryRuleMatches returns [String current=null] 
	:
	{ newCompositeNode(grammarAccess.getMatchesRule()); } 
	 iv_ruleMatches=ruleMatches 
	 { $current=$iv_ruleMatches.current.getText(); }  
	 EOF 
;

// Rule Matches
ruleMatches returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
(
	kw='Match' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getMatchesAccess().getMatchKeyword_0()); 
    }

    { 
        newCompositeNode(grammarAccess.getMatchesAccess().getMatchParserRuleCall_1()); 
    }
    this_Match_1=ruleMatch    {
		$current.merge(this_Match_1);
    }

    { 
        afterParserOrEnumRuleCall();
    }
(
	kw=',' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getMatchesAccess().getCommaKeyword_2_0()); 
    }

    { 
        newCompositeNode(grammarAccess.getMatchesAccess().getMatchParserRuleCall_2_1()); 
    }
    this_Match_3=ruleMatch    {
		$current.merge(this_Match_3);
    }

    { 
        afterParserOrEnumRuleCall();
    }
)*)
    ;





// Entry rule entryRuleMatch
entryRuleMatch returns [String current=null] 
	:
	{ newCompositeNode(grammarAccess.getMatchRule()); } 
	 iv_ruleMatch=ruleMatch 
	 { $current=$iv_ruleMatch.current.getText(); }  
	 EOF 
;

// Rule Match
ruleMatch returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
(    this_NemoId_0=RULE_NEMOID    {
		$current.merge(this_NemoId_0);
    }

    { 
    newLeafNode(this_NemoId_0, grammarAccess.getMatchAccess().getNemoIdTerminalRuleCall_0()); 
    }

	kw=':' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getMatchAccess().getColonKeyword_1()); 
    }
    this_STRING_2=RULE_STRING    {
		$current.merge(this_STRING_2);
    }

    { 
    newLeafNode(this_STRING_2, grammarAccess.getMatchAccess().getSTRINGTerminalRuleCall_2()); 
    }
)
    ;





// Entry rule entryRuleOperation
entryRuleOperation returns [EObject current=null] 
	:
	{ newCompositeNode(grammarAccess.getOperationRule()); }
	 iv_ruleOperation=ruleOperation 
	 { $current=$iv_ruleOperation.current; } 
	 EOF 
;

// Rule Operation
ruleOperation returns [EObject current=null] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
(	otherlv_0='CREATE' 
    {
    	newLeafNode(otherlv_0, grammarAccess.getOperationAccess().getCREATEKeyword_0());
    }
	otherlv_1='Operation' 
    {
    	newLeafNode(otherlv_1, grammarAccess.getOperationAccess().getOperationKeyword_1());
    }
(
(
		lv_name_2_0=RULE_NEMOID
		{
			newLeafNode(lv_name_2_0, grammarAccess.getOperationAccess().getNameNemoIdTerminalRuleCall_2_0()); 
		}
		{
	        if ($current==null) {
	            $current = createModelElement(grammarAccess.getOperationRule());
	        }
       		setWithLastConsumed(
       			$current, 
       			"name",
        		lv_name_2_0, 
        		"NemoId");
	    }

)
)(	otherlv_3='Priority' 
    {
    	newLeafNode(otherlv_3, grammarAccess.getOperationAccess().getPriorityKeyword_3_0());
    }
(
(
		lv_value_4_0=RULE_INT
		{
			newLeafNode(lv_value_4_0, grammarAccess.getOperationAccess().getValueINTTerminalRuleCall_3_1_0()); 
		}
		{
	        if ($current==null) {
	            $current = createModelElement(grammarAccess.getOperationRule());
	        }
       		addWithLastConsumed(
       			$current, 
       			"value",
        		lv_value_4_0, 
        		"INT");
	    }

)
))?	otherlv_5='Target' 
    {
    	newLeafNode(otherlv_5, grammarAccess.getOperationAccess().getTargetKeyword_4());
    }
(
(
		{
			if ($current==null) {
	            $current = createModelElement(grammarAccess.getOperationRule());
	        }
        }
	otherlv_6=RULE_NEMOID
	{
		newLeafNode(otherlv_6, grammarAccess.getOperationAccess().getTargetIdFlowCrossReference_5_0()); 
	}

)
)(
    { 
        newCompositeNode(grammarAccess.getOperationAccess().getConditionParserRuleCall_6()); 
    }
ruleCondition
    { 
        afterParserOrEnumRuleCall();
    }
)?	otherlv_8='Action' 
    {
    	newLeafNode(otherlv_8, grammarAccess.getOperationAccess().getActionKeyword_7());
    }
(this_NemoId_9=RULE_NEMOID
    { 
    newLeafNode(this_NemoId_9, grammarAccess.getOperationAccess().getNemoIdTerminalRuleCall_8_0()); 
    }

    |(this_NemoId_10=RULE_NEMOID
    { 
    newLeafNode(this_NemoId_10, grammarAccess.getOperationAccess().getNemoIdTerminalRuleCall_8_1_0()); 
    }
	otherlv_11=':' 
    {
    	newLeafNode(otherlv_11, grammarAccess.getOperationAccess().getColonKeyword_8_1_1());
    }
(
(
		{
			if ($current==null) {
	            $current = createModelElement(grammarAccess.getOperationRule());
	        }
        }
	otherlv_12=RULE_NEMOID
	{
		newLeafNode(otherlv_12, grammarAccess.getOperationAccess().getTargetNodeNodeCrossReference_8_1_2_0()); 
	}

)
)))	otherlv_13=';' 
    {
    	newLeafNode(otherlv_13, grammarAccess.getOperationAccess().getSemicolonKeyword_9());
    }
)
;





// Entry rule entryRuleCondition
entryRuleCondition returns [String current=null] 
	:
	{ newCompositeNode(grammarAccess.getConditionRule()); } 
	 iv_ruleCondition=ruleCondition 
	 { $current=$iv_ruleCondition.current.getText(); }  
	 EOF 
;

// Rule Condition
ruleCondition returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
(
	kw='Condition' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getConditionAccess().getConditionKeyword_0()); 
    }
    this_STRING_1=RULE_STRING    {
		$current.merge(this_STRING_1);
    }

    { 
    newLeafNode(this_STRING_1, grammarAccess.getConditionAccess().getSTRINGTerminalRuleCall_1()); 
    }
(
	kw=',' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getConditionAccess().getCommaKeyword_2_0()); 
    }
    this_STRING_3=RULE_STRING    {
		$current.merge(this_STRING_3);
    }

    { 
    newLeafNode(this_STRING_3, grammarAccess.getConditionAccess().getSTRINGTerminalRuleCall_2_1()); 
    }
)*)
    ;





// Entry rule entryRuleProperty
entryRuleProperty returns [String current=null] 
	:
	{ newCompositeNode(grammarAccess.getPropertyRule()); } 
	 iv_ruleProperty=ruleProperty 
	 { $current=$iv_ruleProperty.current.getText(); }  
	 EOF 
;

// Rule Property
ruleProperty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
(
	kw='Property ' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getPropertyAccess().getPropertyKeyword_0()); 
    }

    { 
        newCompositeNode(grammarAccess.getPropertyAccess().getOnePropertyParserRuleCall_1()); 
    }
    this_OneProperty_1=ruleOneProperty    {
		$current.merge(this_OneProperty_1);
    }

    { 
        afterParserOrEnumRuleCall();
    }
(
	kw=',' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getPropertyAccess().getCommaKeyword_2_0()); 
    }

    { 
        newCompositeNode(grammarAccess.getPropertyAccess().getOnePropertyParserRuleCall_2_1()); 
    }
    this_OneProperty_3=ruleOneProperty    {
		$current.merge(this_OneProperty_3);
    }

    { 
        afterParserOrEnumRuleCall();
    }
)*)
    ;





// Entry rule entryRuleOneProperty
entryRuleOneProperty returns [String current=null] 
	:
	{ newCompositeNode(grammarAccess.getOnePropertyRule()); } 
	 iv_ruleOneProperty=ruleOneProperty 
	 { $current=$iv_ruleOneProperty.current.getText(); }  
	 EOF 
;

// Rule OneProperty
ruleOneProperty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
(    this_NemoId_0=RULE_NEMOID    {
		$current.merge(this_NemoId_0);
    }

    { 
    newLeafNode(this_NemoId_0, grammarAccess.getOnePropertyAccess().getNemoIdTerminalRuleCall_0()); 
    }

	kw=':' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getOnePropertyAccess().getColonKeyword_1()); 
    }
(    this_STRING_2=RULE_STRING    {
		$current.merge(this_STRING_2);
    }

    { 
    newLeafNode(this_STRING_2, grammarAccess.getOnePropertyAccess().getSTRINGTerminalRuleCall_2_0()); 
    }

    |    this_INT_3=RULE_INT    {
		$current.merge(this_INT_3);
    }

    { 
    newLeafNode(this_INT_3, grammarAccess.getOnePropertyAccess().getINTTerminalRuleCall_2_1()); 
    }
))
    ;





// Entry rule entryRuleModelProperty
entryRuleModelProperty returns [String current=null] 
	:
	{ newCompositeNode(grammarAccess.getModelPropertyRule()); } 
	 iv_ruleModelProperty=ruleModelProperty 
	 { $current=$iv_ruleModelProperty.current.getText(); }  
	 EOF 
;

// Rule ModelProperty
ruleModelProperty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
(
	kw='Property' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getModelPropertyAccess().getPropertyKeyword_0()); 
    }

    { 
        newCompositeNode(grammarAccess.getModelPropertyAccess().getOneModelPropertyParserRuleCall_1()); 
    }
    this_OneModelProperty_1=ruleOneModelProperty    {
		$current.merge(this_OneModelProperty_1);
    }

    { 
        afterParserOrEnumRuleCall();
    }
(
	kw=',' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getModelPropertyAccess().getCommaKeyword_2_0()); 
    }

    { 
        newCompositeNode(grammarAccess.getModelPropertyAccess().getOneModelPropertyParserRuleCall_2_1()); 
    }
    this_OneModelProperty_3=ruleOneModelProperty    {
		$current.merge(this_OneModelProperty_3);
    }

    { 
        afterParserOrEnumRuleCall();
    }
)*)
    ;





// Entry rule entryRuleOneModelProperty
entryRuleOneModelProperty returns [String current=null] 
	:
	{ newCompositeNode(grammarAccess.getOneModelPropertyRule()); } 
	 iv_ruleOneModelProperty=ruleOneModelProperty 
	 { $current=$iv_ruleOneModelProperty.current.getText(); }  
	 EOF 
;

// Rule OneModelProperty
ruleOneModelProperty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
((    this_STRING_0=RULE_STRING    {
		$current.merge(this_STRING_0);
    }

    { 
    newLeafNode(this_STRING_0, grammarAccess.getOneModelPropertyAccess().getSTRINGTerminalRuleCall_0_0()); 
    }

    |    this_INT_1=RULE_INT    {
		$current.merge(this_INT_1);
    }

    { 
    newLeafNode(this_INT_1, grammarAccess.getOneModelPropertyAccess().getINTTerminalRuleCall_0_1()); 
    }
)
	kw=':' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getOneModelPropertyAccess().getColonKeyword_1()); 
    }
    this_NemoId_3=RULE_NEMOID    {
		$current.merge(this_NemoId_3);
    }

    { 
    newLeafNode(this_NemoId_3, grammarAccess.getOneModelPropertyAccess().getNemoIdTerminalRuleCall_2()); 
    }
)
    ;





// Entry rule entryRuleNewObj
entryRuleNewObj returns [String current=null] 
	:
	{ newCompositeNode(grammarAccess.getNewObjRule()); } 
	 iv_ruleNewObj=ruleNewObj 
	 { $current=$iv_ruleNewObj.current.getText(); }  
	 EOF 
;

// Rule NewObj
ruleNewObj returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] 
    @init { enterRule(); 
    }
    @after { leaveRule(); }:
(
	kw='CREATE' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getNewObjAccess().getCREATEKeyword_0()); 
    }

    |
	kw='IMPORT' 
    {
        $current.merge(kw);
        newLeafNode(kw, grammarAccess.getNewObjAccess().getIMPORTKeyword_1()); 
    }
)
    ;





RULE_IPV4_SUB : ('0'..'9'|'1'..'9' '0'..'9'|'1' '0'..'9' '0'..'9'|'2' '0'..'4' '0'..'9'|'25' '0'..'5');

RULE_NEMOID : ('a'..'z'|'A'..'Z'|'$'|'_') ('a'..'z'|'A'..'Z'|'$'|'_'|'-'|'0'..'9')*;

RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*;

RULE_INT : ('0'..'9')+;

RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\'');

RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/';

RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?;

RULE_WS : (' '|'\t'|'\r'|'\n')+;

RULE_ANY_OTHER : .;