nemo-tools/eclipse-plugin/nemo-editor/org.opendaylight.nemo.tool.eclipse.plugin.editor/bin/org/opendaylight/nemo/tool/eclipse/plugin/parser/antlr/internal/InternalEditor.g

   1 /*
   2  * generated by Xtext
   3  */
   4 grammar InternalEditor;
   5
   6 options {
   7         superClass=AbstractInternalAntlrParser;
   8
   9 }
  10
  11 @lexer::header {
  12 package org.opendaylight.nemo.tool.eclipse.plugin.parser.antlr.internal;
  13
  14 // Hack: Use our own Lexer superclass by means of import.
  15 // Currently there is no other way to specify the superclass for the lexer.
  16 import org.eclipse.xtext.parser.antlr.Lexer;
  17 }
  18
  19 @parser::header {
  20 package org.opendaylight.nemo.tool.eclipse.plugin.parser.antlr.internal;
  21
  22 import org.eclipse.xtext.*;
  23 import org.eclipse.xtext.parser.*;
  24 import org.eclipse.xtext.parser.impl.*;
  25 import org.eclipse.emf.ecore.util.EcoreUtil;
  26 import org.eclipse.emf.ecore.EObject;
  27 import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser;
  28 import org.eclipse.xtext.parser.antlr.XtextTokenStream;
  29 import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
  30 import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
  31 import org.opendaylight.nemo.tool.eclipse.plugin.services.EditorGrammarAccess;
  32
  33 }
  34
  35 @parser::members {
  36
  37         private EditorGrammarAccess grammarAccess;
  38
  39     public InternalEditorParser(TokenStream input, EditorGrammarAccess grammarAccess) {
  40         this(input);
  41         this.grammarAccess = grammarAccess;
  42         registerRules(grammarAccess.getGrammar());
  43     }
  44
  45     @Override
  46     protected String getFirstRuleName() {
  47         return "Model";
  48         }
  49
  50         @Override
  51         protected EditorGrammarAccess getGrammarAccess() {
  52                 return grammarAccess;
  53         }
  54 }
  55
  56 @rulecatch {
  57     catch (RecognitionException re) {
  58         recover(input,re);
  59         appendSkippedTokens();
  60     }
  61 }
  62
  63
  64
  65
  66 // Entry rule entryRuleModel
  67 entryRuleModel returns [EObject current=null]
  68         :
  69         { newCompositeNode(grammarAccess.getModelRule()); }
  70          iv_ruleModel=ruleModel
  71          { $current=$iv_ruleModel.current; }
  72          EOF
  73 ;
  74
  75 // Rule Model
  76 ruleModel returns [EObject current=null]
  77     @init { enterRule();
  78     }
  79     @after { leaveRule(); }:
  80 (
  81 (
  82                 {
  83                 newCompositeNode(grammarAccess.getModelAccess().getSentencesSentenceParserRuleCall_0());
  84             }
  85                 lv_sentences_0_0=ruleSentence           {
  86                 if ($current==null) {
  87                     $current = createModelElementForParent(grammarAccess.getModelRule());
  88                 }
  89                 add(
  90                         $current,
  91                         "sentences",
  92                         lv_sentences_0_0,
  93                         "Sentence");
  94                 afterParserOrEnumRuleCall();
  95             }
  96
  97 )
  98 )*
  99 ;
 100
 101
 102
 103
 104
 105 // Entry rule entryRuleSentence
 106 entryRuleSentence returns [EObject current=null]
 107         :
 108         { newCompositeNode(grammarAccess.getSentenceRule()); }
 109          iv_ruleSentence=ruleSentence
 110          { $current=$iv_ruleSentence.current; }
 111          EOF
 112 ;
 113
 114 // Rule Sentence
 115 ruleSentence returns [EObject current=null]
 116     @init { enterRule();
 117     }
 118     @after { leaveRule(); }:
 119 (
 120     {
 121         newCompositeNode(grammarAccess.getSentenceAccess().getSenEnginesParserRuleCall_0());
 122     }
 123 ruleSenEngines
 124     {
 125         afterParserOrEnumRuleCall();
 126     }
 127
 128     |
 129     {
 130         newCompositeNode(grammarAccess.getSentenceAccess().getUserParserRuleCall_1());
 131     }
 132 ruleUser
 133     {
 134         afterParserOrEnumRuleCall();
 135     }
 136
 137     |
 138     {
 139         newCompositeNode(grammarAccess.getSentenceAccess().getNodeParserRuleCall_2());
 140     }
 141     this_Node_2=ruleNode
 142     {
 143         $current = $this_Node_2.current;
 144         afterParserOrEnumRuleCall();
 145     }
 146
 147     |
 148     {
 149         newCompositeNode(grammarAccess.getSentenceAccess().getNodeOperatingParserRuleCall_3());
 150     }
 151     this_NodeOperating_3=ruleNodeOperating
 152     {
 153         $current = $this_NodeOperating_3.current;
 154         afterParserOrEnumRuleCall();
 155     }
 156
 157     |
 158     {
 159         newCompositeNode(grammarAccess.getSentenceAccess().getConnectionParserRuleCall_4());
 160     }
 161     this_Connection_4=ruleConnection
 162     {
 163         $current = $this_Connection_4.current;
 164         afterParserOrEnumRuleCall();
 165     }
 166
 167     |
 168     {
 169         newCompositeNode(grammarAccess.getSentenceAccess().getConnectionUpdateParserRuleCall_5());
 170     }
 171     this_ConnectionUpdate_5=ruleConnectionUpdate
 172     {
 173         $current = $this_ConnectionUpdate_5.current;
 174         afterParserOrEnumRuleCall();
 175     }
 176
 177     |
 178     {
 179         newCompositeNode(grammarAccess.getSentenceAccess().getFlowParserRuleCall_6());
 180     }
 181     this_Flow_6=ruleFlow
 182     {
 183         $current = $this_Flow_6.current;
 184         afterParserOrEnumRuleCall();
 185     }
 186
 187     |
 188     {
 189         newCompositeNode(grammarAccess.getSentenceAccess().getFlowUpdateParserRuleCall_7());
 190     }
 191     this_FlowUpdate_7=ruleFlowUpdate
 192     {
 193         $current = $this_FlowUpdate_7.current;
 194         afterParserOrEnumRuleCall();
 195     }
 196
 197     |
 198     {
 199         newCompositeNode(grammarAccess.getSentenceAccess().getOperationParserRuleCall_8());
 200     }
 201     this_Operation_8=ruleOperation
 202     {
 203         $current = $this_Operation_8.current;
 204         afterParserOrEnumRuleCall();
 205     }
 206 )
 207 ;
 208
 209
 210
 211
 212
 213 // Entry rule entryRuleSenEngines
 214 entryRuleSenEngines returns [String current=null]
 215         :
 216         { newCompositeNode(grammarAccess.getSenEnginesRule()); }
 217          iv_ruleSenEngines=ruleSenEngines
 218          { $current=$iv_ruleSenEngines.current.getText(); }
 219          EOF
 220 ;
 221
 222 // Rule SenEngines
 223 ruleSenEngines returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
 224     @init { enterRule();
 225     }
 226     @after { leaveRule(); }:
 227 (
 228         kw='Engines:'
 229     {
 230         $current.merge(kw);
 231         newLeafNode(kw, grammarAccess.getSenEnginesAccess().getEnginesKeyword_0());
 232     }
 233
 234     {
 235         newCompositeNode(grammarAccess.getSenEnginesAccess().getIpv4ParserRuleCall_1());
 236     }
 237     this_Ipv4_1=ruleIpv4    {
 238                 $current.merge(this_Ipv4_1);
 239     }
 240
 241     {
 242         afterParserOrEnumRuleCall();
 243     }
 244 (
 245         kw=','
 246     {
 247         $current.merge(kw);
 248         newLeafNode(kw, grammarAccess.getSenEnginesAccess().getCommaKeyword_2_0());
 249     }
 250
 251     {
 252         newCompositeNode(grammarAccess.getSenEnginesAccess().getIpv4ParserRuleCall_2_1());
 253     }
 254     this_Ipv4_3=ruleIpv4    {
 255                 $current.merge(this_Ipv4_3);
 256     }
 257
 258     {
 259         afterParserOrEnumRuleCall();
 260     }
 261 )*
 262         kw=';'
 263     {
 264         $current.merge(kw);
 265         newLeafNode(kw, grammarAccess.getSenEnginesAccess().getSemicolonKeyword_3());
 266     }
 267 )
 268     ;
 269
 270
 271
 272
 273
 274 // Entry rule entryRuleIpv4
 275 entryRuleIpv4 returns [String current=null]
 276         :
 277         { newCompositeNode(grammarAccess.getIpv4Rule()); }
 278          iv_ruleIpv4=ruleIpv4
 279          { $current=$iv_ruleIpv4.current.getText(); }
 280          EOF
 281 ;
 282
 283 // Rule Ipv4
 284 ruleIpv4 returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
 285     @init { enterRule();
 286     }
 287     @after { leaveRule(); }:
 288 (    this_IPV4_SUB_0=RULE_IPV4_SUB    {
 289                 $current.merge(this_IPV4_SUB_0);
 290     }
 291
 292     {
 293     newLeafNode(this_IPV4_SUB_0, grammarAccess.getIpv4Access().getIPV4_SUBTerminalRuleCall_0());
 294     }
 295
 296         kw='.'
 297     {
 298         $current.merge(kw);
 299         newLeafNode(kw, grammarAccess.getIpv4Access().getFullStopKeyword_1());
 300     }
 301     this_IPV4_SUB_2=RULE_IPV4_SUB    {
 302                 $current.merge(this_IPV4_SUB_2);
 303     }
 304
 305     {
 306     newLeafNode(this_IPV4_SUB_2, grammarAccess.getIpv4Access().getIPV4_SUBTerminalRuleCall_2());
 307     }
 308
 309         kw='.'
 310     {
 311         $current.merge(kw);
 312         newLeafNode(kw, grammarAccess.getIpv4Access().getFullStopKeyword_3());
 313     }
 314     this_IPV4_SUB_4=RULE_IPV4_SUB    {
 315                 $current.merge(this_IPV4_SUB_4);
 316     }
 317
 318     {
 319     newLeafNode(this_IPV4_SUB_4, grammarAccess.getIpv4Access().getIPV4_SUBTerminalRuleCall_4());
 320     }
 321
 322         kw='.'
 323     {
 324         $current.merge(kw);
 325         newLeafNode(kw, grammarAccess.getIpv4Access().getFullStopKeyword_5());
 326     }
 327     this_IPV4_SUB_6=RULE_IPV4_SUB    {
 328                 $current.merge(this_IPV4_SUB_6);
 329     }
 330
 331     {
 332     newLeafNode(this_IPV4_SUB_6, grammarAccess.getIpv4Access().getIPV4_SUBTerminalRuleCall_6());
 333     }
 334 )
 335     ;
 336
 337
 338
 339
 340
 341 // Entry rule entryRuleUser
 342 entryRuleUser returns [String current=null]
 343         :
 344         { newCompositeNode(grammarAccess.getUserRule()); }
 345          iv_ruleUser=ruleUser
 346          { $current=$iv_ruleUser.current.getText(); }
 347          EOF
 348 ;
 349
 350 // Rule User
 351 ruleUser returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
 352     @init { enterRule();
 353     }
 354     @after { leaveRule(); }:
 355 (
 356         kw='CREATE'
 357     {
 358         $current.merge(kw);
 359         newLeafNode(kw, grammarAccess.getUserAccess().getCREATEKeyword_0());
 360     }
 361     this_STRING_1=RULE_STRING    {
 362                 $current.merge(this_STRING_1);
 363     }
 364
 365     {
 366     newLeafNode(this_STRING_1, grammarAccess.getUserAccess().getSTRINGTerminalRuleCall_1());
 367     }
 368     this_STRING_2=RULE_STRING    {
 369                 $current.merge(this_STRING_2);
 370     }
 371
 372     {
 373     newLeafNode(this_STRING_2, grammarAccess.getUserAccess().getSTRINGTerminalRuleCall_2());
 374     }
 375     this_STRING_3=RULE_STRING    {
 376                 $current.merge(this_STRING_3);
 377     }
 378
 379     {
 380     newLeafNode(this_STRING_3, grammarAccess.getUserAccess().getSTRINGTerminalRuleCall_3());
 381     }
 382
 383         kw=';'
 384     {
 385         $current.merge(kw);
 386         newLeafNode(kw, grammarAccess.getUserAccess().getSemicolonKeyword_4());
 387     }
 388 )
 389     ;
 390
 391
 392
 393
 394
 395 // Entry rule entryRuleNode
 396 entryRuleNode returns [EObject current=null]
 397         :
 398         { newCompositeNode(grammarAccess.getNodeRule()); }
 399          iv_ruleNode=ruleNode
 400          { $current=$iv_ruleNode.current; }
 401          EOF
 402 ;
 403
 404 // Rule Node
 405 ruleNode returns [EObject current=null]
 406     @init { enterRule();
 407     }
 408     @after { leaveRule(); }:
 409 (
 410     {
 411         newCompositeNode(grammarAccess.getNodeAccess().getNewObjParserRuleCall_0());
 412     }
 413 ruleNewObj
 414     {
 415         afterParserOrEnumRuleCall();
 416     }
 417         otherlv_1='Node'
 418     {
 419         newLeafNode(otherlv_1, grammarAccess.getNodeAccess().getNodeKeyword_1());
 420     }
 421 (
 422 (
 423                 lv_name_2_0=RULE_NEMOID
 424                 {
 425                         newLeafNode(lv_name_2_0, grammarAccess.getNodeAccess().getNameNemoIdTerminalRuleCall_2_0());
 426                 }
 427                 {
 428                 if ($current==null) {
 429                     $current = createModelElement(grammarAccess.getNodeRule());
 430                 }
 431                 setWithLastConsumed(
 432                         $current,
 433                         "name",
 434                         lv_name_2_0,
 435                         "NemoId");
 436             }
 437
 438 )
 439 )(      otherlv_3='Type'
 440     {
 441         newLeafNode(otherlv_3, grammarAccess.getNodeAccess().getTypeKeyword_3_0());
 442     }
 443 this_NemoId_4=RULE_NEMOID
 444     {
 445     newLeafNode(this_NemoId_4, grammarAccess.getNodeAccess().getNemoIdTerminalRuleCall_3_1());
 446     }
 447 )(      otherlv_5='Contain'
 448     {
 449         newLeafNode(otherlv_5, grammarAccess.getNodeAccess().getContainKeyword_4_0());
 450     }
 451 (
 452 (
 453                 {
 454                         if ($current==null) {
 455                     $current = createModelElement(grammarAccess.getNodeRule());
 456                 }
 457         }
 458         otherlv_6=RULE_NEMOID
 459         {
 460                 newLeafNode(otherlv_6, grammarAccess.getNodeAccess().getNodesNodeCrossReference_4_1_0());
 461         }
 462
 463 )
 464 )(      otherlv_7=','
 465     {
 466         newLeafNode(otherlv_7, grammarAccess.getNodeAccess().getCommaKeyword_4_2_0());
 467     }
 468 (
 469 (
 470                 {
 471                         if ($current==null) {
 472                     $current = createModelElement(grammarAccess.getNodeRule());
 473                 }
 474         }
 475         otherlv_8=RULE_NEMOID
 476         {
 477                 newLeafNode(otherlv_8, grammarAccess.getNodeAccess().getNodesNodeCrossReference_4_2_1_0());
 478         }
 479
 480 )
 481 ))*)?(
 482     {
 483         newCompositeNode(grammarAccess.getNodeAccess().getPropertyParserRuleCall_5());
 484     }
 485 ruleProperty
 486     {
 487         afterParserOrEnumRuleCall();
 488     }
 489 )?      otherlv_10=';'
 490     {
 491         newLeafNode(otherlv_10, grammarAccess.getNodeAccess().getSemicolonKeyword_6());
 492     }
 493 )
 494 ;
 495
 496
 497
 498
 499
 500
 501
 502 // Entry rule entryRuleNodeOperating
 503 entryRuleNodeOperating returns [EObject current=null]
 504         :
 505         { newCompositeNode(grammarAccess.getNodeOperatingRule()); }
 506          iv_ruleNodeOperating=ruleNodeOperating
 507          { $current=$iv_ruleNodeOperating.current; }
 508          EOF
 509 ;
 510
 511 // Rule NodeOperating
 512 ruleNodeOperating returns [EObject current=null]
 513     @init { enterRule();
 514     }
 515     @after { leaveRule(); }:
 516 ((      otherlv_0='UPDATE'
 517     {
 518         newLeafNode(otherlv_0, grammarAccess.getNodeOperatingAccess().getUPDATEKeyword_0_0());
 519     }
 520
 521     |   otherlv_1='DELETE'
 522     {
 523         newLeafNode(otherlv_1, grammarAccess.getNodeOperatingAccess().getDELETEKeyword_0_1());
 524     }
 525 )       otherlv_2='Node'
 526     {
 527         newLeafNode(otherlv_2, grammarAccess.getNodeOperatingAccess().getNodeKeyword_1());
 528     }
 529 (
 530 (
 531                 {
 532                         if ($current==null) {
 533                     $current = createModelElement(grammarAccess.getNodeOperatingRule());
 534                 }
 535         }
 536         otherlv_3=RULE_NEMOID
 537         {
 538                 newLeafNode(otherlv_3, grammarAccess.getNodeOperatingAccess().getNodenameNodeCrossReference_2_0());
 539         }
 540
 541 )
 542 )(      otherlv_4='Type'
 543     {
 544         newLeafNode(otherlv_4, grammarAccess.getNodeOperatingAccess().getTypeKeyword_3_0());
 545     }
 546 this_NemoId_5=RULE_NEMOID
 547     {
 548     newLeafNode(this_NemoId_5, grammarAccess.getNodeOperatingAccess().getNemoIdTerminalRuleCall_3_1());
 549     }
 550 )?(     otherlv_6='Contain'
 551     {
 552         newLeafNode(otherlv_6, grammarAccess.getNodeOperatingAccess().getContainKeyword_4_0());
 553     }
 554 (
 555 (
 556                 {
 557                         if ($current==null) {
 558                     $current = createModelElement(grammarAccess.getNodeOperatingRule());
 559                 }
 560         }
 561         otherlv_7=RULE_NEMOID
 562         {
 563                 newLeafNode(otherlv_7, grammarAccess.getNodeOperatingAccess().getNodesNodeCrossReference_4_1_0());
 564         }
 565
 566 )
 567 )(      otherlv_8=','
 568     {
 569         newLeafNode(otherlv_8, grammarAccess.getNodeOperatingAccess().getCommaKeyword_4_2_0());
 570     }
 571 (
 572 (
 573                 {
 574                         if ($current==null) {
 575                     $current = createModelElement(grammarAccess.getNodeOperatingRule());
 576                 }
 577         }
 578         otherlv_9=RULE_NEMOID
 579         {
 580                 newLeafNode(otherlv_9, grammarAccess.getNodeOperatingAccess().getNodesNodeCrossReference_4_2_1_0());
 581         }
 582
 583 )
 584 ))*)?(
 585     {
 586         newCompositeNode(grammarAccess.getNodeOperatingAccess().getPropertyParserRuleCall_5());
 587     }
 588 ruleProperty
 589     {
 590         afterParserOrEnumRuleCall();
 591     }
 592 )?      otherlv_11=';'
 593     {
 594         newLeafNode(otherlv_11, grammarAccess.getNodeOperatingAccess().getSemicolonKeyword_6());
 595     }
 596 )
 597 ;
 598
 599
 600
 601
 602
 603 // Entry rule entryRuleConnection
 604 entryRuleConnection returns [EObject current=null]
 605         :
 606         { newCompositeNode(grammarAccess.getConnectionRule()); }
 607          iv_ruleConnection=ruleConnection
 608          { $current=$iv_ruleConnection.current; }
 609          EOF
 610 ;
 611
 612 // Rule Connection
 613 ruleConnection returns [EObject current=null]
 614     @init { enterRule();
 615     }
 616     @after { leaveRule(); }:
 617 (       otherlv_0='CREATE'
 618     {
 619         newLeafNode(otherlv_0, grammarAccess.getConnectionAccess().getCREATEKeyword_0());
 620     }
 621         otherlv_1='Connection'
 622     {
 623         newLeafNode(otherlv_1, grammarAccess.getConnectionAccess().getConnectionKeyword_1());
 624     }
 625 (
 626 (
 627                 lv_name_2_0=RULE_NEMOID
 628                 {
 629                         newLeafNode(lv_name_2_0, grammarAccess.getConnectionAccess().getNameNemoIdTerminalRuleCall_2_0());
 630                 }
 631                 {
 632                 if ($current==null) {
 633                     $current = createModelElement(grammarAccess.getConnectionRule());
 634                 }
 635                 setWithLastConsumed(
 636                         $current,
 637                         "name",
 638                         lv_name_2_0,
 639                         "NemoId");
 640             }
 641
 642 )
 643 )       otherlv_3='Type'
 644     {
 645         newLeafNode(otherlv_3, grammarAccess.getConnectionAccess().getTypeKeyword_3());
 646     }
 647 this_NemoId_4=RULE_NEMOID
 648     {
 649     newLeafNode(this_NemoId_4, grammarAccess.getConnectionAccess().getNemoIdTerminalRuleCall_4());
 650     }
 651 (       otherlv_5='Endnodes'
 652     {
 653         newLeafNode(otherlv_5, grammarAccess.getConnectionAccess().getEndnodesKeyword_5_0());
 654     }
 655 (
 656 (
 657                 {
 658                         if ($current==null) {
 659                     $current = createModelElement(grammarAccess.getConnectionRule());
 660                 }
 661         }
 662         otherlv_6=RULE_NEMOID
 663         {
 664                 newLeafNode(otherlv_6, grammarAccess.getConnectionAccess().getEndnodeNodeCrossReference_5_1_0());
 665         }
 666
 667 )
 668 )(      otherlv_7=','
 669     {
 670         newLeafNode(otherlv_7, grammarAccess.getConnectionAccess().getCommaKeyword_5_2_0());
 671     }
 672 (
 673 (
 674                 {
 675                         if ($current==null) {
 676                     $current = createModelElement(grammarAccess.getConnectionRule());
 677                 }
 678         }
 679         otherlv_8=RULE_NEMOID
 680         {
 681                 newLeafNode(otherlv_8, grammarAccess.getConnectionAccess().getEndnodeNodeCrossReference_5_2_1_0());
 682         }
 683
 684 )
 685 ))*)(
 686     {
 687         newCompositeNode(grammarAccess.getConnectionAccess().getPropertyParserRuleCall_6());
 688     }
 689 ruleProperty
 690     {
 691         afterParserOrEnumRuleCall();
 692     }
 693 )?      otherlv_10=';'
 694     {
 695         newLeafNode(otherlv_10, grammarAccess.getConnectionAccess().getSemicolonKeyword_7());
 696     }
 697 )
 698 ;
 699
 700
 701
 702
 703
 704 // Entry rule entryRuleConnectionUpdate
 705 entryRuleConnectionUpdate returns [EObject current=null]
 706         :
 707         { newCompositeNode(grammarAccess.getConnectionUpdateRule()); }
 708          iv_ruleConnectionUpdate=ruleConnectionUpdate
 709          { $current=$iv_ruleConnectionUpdate.current; }
 710          EOF
 711 ;
 712
 713 // Rule ConnectionUpdate
 714 ruleConnectionUpdate returns [EObject current=null]
 715     @init { enterRule();
 716     }
 717     @after { leaveRule(); }:
 718 ((      otherlv_0='UPDATE'
 719     {
 720         newLeafNode(otherlv_0, grammarAccess.getConnectionUpdateAccess().getUPDATEKeyword_0_0());
 721     }
 722
 723     |   otherlv_1='DELETE'
 724     {
 725         newLeafNode(otherlv_1, grammarAccess.getConnectionUpdateAccess().getDELETEKeyword_0_1());
 726     }
 727 )       otherlv_2='Connection'
 728     {
 729         newLeafNode(otherlv_2, grammarAccess.getConnectionUpdateAccess().getConnectionKeyword_1());
 730     }
 731 (
 732 (
 733                 {
 734                         if ($current==null) {
 735                     $current = createModelElement(grammarAccess.getConnectionUpdateRule());
 736                 }
 737         }
 738         otherlv_3=RULE_NEMOID
 739         {
 740                 newLeafNode(otherlv_3, grammarAccess.getConnectionUpdateAccess().getConnectionnameConnectionCrossReference_2_0());
 741         }
 742
 743 )
 744 )(      otherlv_4='Type'
 745     {
 746         newLeafNode(otherlv_4, grammarAccess.getConnectionUpdateAccess().getTypeKeyword_3_0());
 747     }
 748 this_NemoId_5=RULE_NEMOID
 749     {
 750     newLeafNode(this_NemoId_5, grammarAccess.getConnectionUpdateAccess().getNemoIdTerminalRuleCall_3_1());
 751     }
 752 )?(     otherlv_6='Endnodes'
 753     {
 754         newLeafNode(otherlv_6, grammarAccess.getConnectionUpdateAccess().getEndnodesKeyword_4_0());
 755     }
 756 (
 757 (
 758                 {
 759                         if ($current==null) {
 760                     $current = createModelElement(grammarAccess.getConnectionUpdateRule());
 761                 }
 762         }
 763         otherlv_7=RULE_NEMOID
 764         {
 765                 newLeafNode(otherlv_7, grammarAccess.getConnectionUpdateAccess().getEndnodeNodeCrossReference_4_1_0());
 766         }
 767
 768 )
 769 )(      otherlv_8=','
 770     {
 771         newLeafNode(otherlv_8, grammarAccess.getConnectionUpdateAccess().getCommaKeyword_4_2_0());
 772     }
 773 (
 774 (
 775                 {
 776                         if ($current==null) {
 777                     $current = createModelElement(grammarAccess.getConnectionUpdateRule());
 778                 }
 779         }
 780         otherlv_9=RULE_NEMOID
 781         {
 782                 newLeafNode(otherlv_9, grammarAccess.getConnectionUpdateAccess().getEndnodeNodeCrossReference_4_2_1_0());
 783         }
 784
 785 )
 786 ))*)?(
 787     {
 788         newCompositeNode(grammarAccess.getConnectionUpdateAccess().getPropertyParserRuleCall_5());
 789     }
 790 ruleProperty
 791     {
 792         afterParserOrEnumRuleCall();
 793     }
 794 )?      otherlv_11=';'
 795     {
 796         newLeafNode(otherlv_11, grammarAccess.getConnectionUpdateAccess().getSemicolonKeyword_6());
 797     }
 798 )
 799 ;
 800
 801
 802
 803
 804
 805 // Entry rule entryRuleFlow
 806 entryRuleFlow returns [EObject current=null]
 807         :
 808         { newCompositeNode(grammarAccess.getFlowRule()); }
 809          iv_ruleFlow=ruleFlow
 810          { $current=$iv_ruleFlow.current; }
 811          EOF
 812 ;
 813
 814 // Rule Flow
 815 ruleFlow returns [EObject current=null]
 816     @init { enterRule();
 817     }
 818     @after { leaveRule(); }:
 819 (       otherlv_0='CREATE'
 820     {
 821         newLeafNode(otherlv_0, grammarAccess.getFlowAccess().getCREATEKeyword_0());
 822     }
 823         otherlv_1='Flow'
 824     {
 825         newLeafNode(otherlv_1, grammarAccess.getFlowAccess().getFlowKeyword_1());
 826     }
 827 (
 828 (
 829                 lv_name_2_0=RULE_NEMOID
 830                 {
 831                         newLeafNode(lv_name_2_0, grammarAccess.getFlowAccess().getNameNemoIdTerminalRuleCall_2_0());
 832                 }
 833                 {
 834                 if ($current==null) {
 835                     $current = createModelElement(grammarAccess.getFlowRule());
 836                 }
 837                 setWithLastConsumed(
 838                         $current,
 839                         "name",
 840                         lv_name_2_0,
 841                         "NemoId");
 842             }
 843
 844 )
 845 )(
 846     {
 847         newCompositeNode(grammarAccess.getFlowAccess().getMatchesParserRuleCall_3());
 848     }
 849 ruleMatches
 850     {
 851         afterParserOrEnumRuleCall();
 852     }
 853 )?      otherlv_4=';'
 854     {
 855         newLeafNode(otherlv_4, grammarAccess.getFlowAccess().getSemicolonKeyword_4());
 856     }
 857 )
 858 ;
 859
 860
 861
 862
 863
 864 // Entry rule entryRuleFlowUpdate
 865 entryRuleFlowUpdate returns [EObject current=null]
 866         :
 867         { newCompositeNode(grammarAccess.getFlowUpdateRule()); }
 868          iv_ruleFlowUpdate=ruleFlowUpdate
 869          { $current=$iv_ruleFlowUpdate.current; }
 870          EOF
 871 ;
 872
 873 // Rule FlowUpdate
 874 ruleFlowUpdate returns [EObject current=null]
 875     @init { enterRule();
 876     }
 877     @after { leaveRule(); }:
 878 ((      otherlv_0='UPDATE'
 879     {
 880         newLeafNode(otherlv_0, grammarAccess.getFlowUpdateAccess().getUPDATEKeyword_0_0());
 881     }
 882
 883     |   otherlv_1='DELETE'
 884     {
 885         newLeafNode(otherlv_1, grammarAccess.getFlowUpdateAccess().getDELETEKeyword_0_1());
 886     }
 887 )       otherlv_2='Flow'
 888     {
 889         newLeafNode(otherlv_2, grammarAccess.getFlowUpdateAccess().getFlowKeyword_1());
 890     }
 891 (
 892 (
 893                 {
 894                         if ($current==null) {
 895                     $current = createModelElement(grammarAccess.getFlowUpdateRule());
 896                 }
 897         }
 898         otherlv_3=RULE_NEMOID
 899         {
 900                 newLeafNode(otherlv_3, grammarAccess.getFlowUpdateAccess().getFlowIdFlowCrossReference_2_0());
 901         }
 902
 903 )
 904 )(
 905     {
 906         newCompositeNode(grammarAccess.getFlowUpdateAccess().getMatchesParserRuleCall_3());
 907     }
 908 ruleMatches
 909     {
 910         afterParserOrEnumRuleCall();
 911     }
 912 )?      otherlv_5=';'
 913     {
 914         newLeafNode(otherlv_5, grammarAccess.getFlowUpdateAccess().getSemicolonKeyword_4());
 915     }
 916 )
 917 ;
 918
 919
 920
 921
 922
 923 // Entry rule entryRuleMatches
 924 entryRuleMatches returns [String current=null]
 925         :
 926         { newCompositeNode(grammarAccess.getMatchesRule()); }
 927          iv_ruleMatches=ruleMatches
 928          { $current=$iv_ruleMatches.current.getText(); }
 929          EOF
 930 ;
 931
 932 // Rule Matches
 933 ruleMatches returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
 934     @init { enterRule();
 935     }
 936     @after { leaveRule(); }:
 937 (
 938         kw='Match'
 939     {
 940         $current.merge(kw);
 941         newLeafNode(kw, grammarAccess.getMatchesAccess().getMatchKeyword_0());
 942     }
 943
 944     {
 945         newCompositeNode(grammarAccess.getMatchesAccess().getMatchParserRuleCall_1());
 946     }
 947     this_Match_1=ruleMatch    {
 948                 $current.merge(this_Match_1);
 949     }
 950
 951     {
 952         afterParserOrEnumRuleCall();
 953     }
 954 (
 955         kw=','
 956     {
 957         $current.merge(kw);
 958         newLeafNode(kw, grammarAccess.getMatchesAccess().getCommaKeyword_2_0());
 959     }
 960
 961     {
 962         newCompositeNode(grammarAccess.getMatchesAccess().getMatchParserRuleCall_2_1());
 963     }
 964     this_Match_3=ruleMatch    {
 965                 $current.merge(this_Match_3);
 966     }
 967
 968     {
 969         afterParserOrEnumRuleCall();
 970     }
 971 )*)
 972     ;
 973
 974
 975
 976
 977
 978 // Entry rule entryRuleMatch
 979 entryRuleMatch returns [String current=null]
 980         :
 981         { newCompositeNode(grammarAccess.getMatchRule()); }
 982          iv_ruleMatch=ruleMatch
 983          { $current=$iv_ruleMatch.current.getText(); }
 984          EOF
 985 ;
 986
 987 // Rule Match
 988 ruleMatch returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
 989     @init { enterRule();
 990     }
 991     @after { leaveRule(); }:
 992 (    this_NemoId_0=RULE_NEMOID    {
 993                 $current.merge(this_NemoId_0);
 994     }
 995
 996     {
 997     newLeafNode(this_NemoId_0, grammarAccess.getMatchAccess().getNemoIdTerminalRuleCall_0());
 998     }
 999
1000         kw=':'
1001     {
1002         $current.merge(kw);
1003         newLeafNode(kw, grammarAccess.getMatchAccess().getColonKeyword_1());
1004     }
1005     this_STRING_2=RULE_STRING    {
1006                 $current.merge(this_STRING_2);
1007     }
1008
1009     {
1010     newLeafNode(this_STRING_2, grammarAccess.getMatchAccess().getSTRINGTerminalRuleCall_2());
1011     }
1012 )
1013     ;
1014
1015
1016
1017
1018
1019 // Entry rule entryRuleOperation
1020 entryRuleOperation returns [EObject current=null]
1021         :
1022         { newCompositeNode(grammarAccess.getOperationRule()); }
1023          iv_ruleOperation=ruleOperation
1024          { $current=$iv_ruleOperation.current; }
1025          EOF
1026 ;
1027
1028 // Rule Operation
1029 ruleOperation returns [EObject current=null]
1030     @init { enterRule();
1031     }
1032     @after { leaveRule(); }:
1033 (       otherlv_0='CREATE'
1034     {
1035         newLeafNode(otherlv_0, grammarAccess.getOperationAccess().getCREATEKeyword_0());
1036     }
1037         otherlv_1='Operation'
1038     {
1039         newLeafNode(otherlv_1, grammarAccess.getOperationAccess().getOperationKeyword_1());
1040     }
1041 (
1042 (
1043                 lv_name_2_0=RULE_NEMOID
1044                 {
1045                         newLeafNode(lv_name_2_0, grammarAccess.getOperationAccess().getNameNemoIdTerminalRuleCall_2_0());
1046                 }
1047                 {
1048                 if ($current==null) {
1049                     $current = createModelElement(grammarAccess.getOperationRule());
1050                 }
1051                 setWithLastConsumed(
1052                         $current,
1053                         "name",
1054                         lv_name_2_0,
1055                         "NemoId");
1056             }
1057
1058 )
1059 )(      otherlv_3='Priority'
1060     {
1061         newLeafNode(otherlv_3, grammarAccess.getOperationAccess().getPriorityKeyword_3_0());
1062     }
1063 (
1064 (
1065                 lv_value_4_0=RULE_INT
1066                 {
1067                         newLeafNode(lv_value_4_0, grammarAccess.getOperationAccess().getValueINTTerminalRuleCall_3_1_0());
1068                 }
1069                 {
1070                 if ($current==null) {
1071                     $current = createModelElement(grammarAccess.getOperationRule());
1072                 }
1073                 addWithLastConsumed(
1074                         $current,
1075                         "value",
1076                         lv_value_4_0,
1077                         "INT");
1078             }
1079
1080 )
1081 ))?     otherlv_5='Target'
1082     {
1083         newLeafNode(otherlv_5, grammarAccess.getOperationAccess().getTargetKeyword_4());
1084     }
1085 (
1086 (
1087                 {
1088                         if ($current==null) {
1089                     $current = createModelElement(grammarAccess.getOperationRule());
1090                 }
1091         }
1092         otherlv_6=RULE_NEMOID
1093         {
1094                 newLeafNode(otherlv_6, grammarAccess.getOperationAccess().getTargetIdFlowCrossReference_5_0());
1095         }
1096
1097 )
1098 )(
1099     {
1100         newCompositeNode(grammarAccess.getOperationAccess().getConditionParserRuleCall_6());
1101     }
1102 ruleCondition
1103     {
1104         afterParserOrEnumRuleCall();
1105     }
1106 )?      otherlv_8='Action'
1107     {
1108         newLeafNode(otherlv_8, grammarAccess.getOperationAccess().getActionKeyword_7());
1109     }
1110 (this_NemoId_9=RULE_NEMOID
1111     {
1112     newLeafNode(this_NemoId_9, grammarAccess.getOperationAccess().getNemoIdTerminalRuleCall_8_0());
1113     }
1114
1115     |(this_NemoId_10=RULE_NEMOID
1116     {
1117     newLeafNode(this_NemoId_10, grammarAccess.getOperationAccess().getNemoIdTerminalRuleCall_8_1_0());
1118     }
1119         otherlv_11=':'
1120     {
1121         newLeafNode(otherlv_11, grammarAccess.getOperationAccess().getColonKeyword_8_1_1());
1122     }
1123 (
1124 (
1125                 {
1126                         if ($current==null) {
1127                     $current = createModelElement(grammarAccess.getOperationRule());
1128                 }
1129         }
1130         otherlv_12=RULE_NEMOID
1131         {
1132                 newLeafNode(otherlv_12, grammarAccess.getOperationAccess().getTargetNodeNodeCrossReference_8_1_2_0());
1133         }
1134
1135 )
1136 )))     otherlv_13=';'
1137     {
1138         newLeafNode(otherlv_13, grammarAccess.getOperationAccess().getSemicolonKeyword_9());
1139     }
1140 )
1141 ;
1142
1143
1144
1145
1146
1147 // Entry rule entryRuleCondition
1148 entryRuleCondition returns [String current=null]
1149         :
1150         { newCompositeNode(grammarAccess.getConditionRule()); }
1151          iv_ruleCondition=ruleCondition
1152          { $current=$iv_ruleCondition.current.getText(); }
1153          EOF
1154 ;
1155
1156 // Rule Condition
1157 ruleCondition returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
1158     @init { enterRule();
1159     }
1160     @after { leaveRule(); }:
1161 (
1162         kw='Condition'
1163     {
1164         $current.merge(kw);
1165         newLeafNode(kw, grammarAccess.getConditionAccess().getConditionKeyword_0());
1166     }
1167     this_STRING_1=RULE_STRING    {
1168                 $current.merge(this_STRING_1);
1169     }
1170
1171     {
1172     newLeafNode(this_STRING_1, grammarAccess.getConditionAccess().getSTRINGTerminalRuleCall_1());
1173     }
1174 (
1175         kw=','
1176     {
1177         $current.merge(kw);
1178         newLeafNode(kw, grammarAccess.getConditionAccess().getCommaKeyword_2_0());
1179     }
1180     this_STRING_3=RULE_STRING    {
1181                 $current.merge(this_STRING_3);
1182     }
1183
1184     {
1185     newLeafNode(this_STRING_3, grammarAccess.getConditionAccess().getSTRINGTerminalRuleCall_2_1());
1186     }
1187 )*)
1188     ;
1189
1190
1191
1192
1193
1194 // Entry rule entryRuleProperty
1195 entryRuleProperty returns [String current=null]
1196         :
1197         { newCompositeNode(grammarAccess.getPropertyRule()); }
1198          iv_ruleProperty=ruleProperty
1199          { $current=$iv_ruleProperty.current.getText(); }
1200          EOF
1201 ;
1202
1203 // Rule Property
1204 ruleProperty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
1205     @init { enterRule();
1206     }
1207     @after { leaveRule(); }:
1208 (
1209         kw='Property '
1210     {
1211         $current.merge(kw);
1212         newLeafNode(kw, grammarAccess.getPropertyAccess().getPropertyKeyword_0());
1213     }
1214
1215     {
1216         newCompositeNode(grammarAccess.getPropertyAccess().getOnePropertyParserRuleCall_1());
1217     }
1218     this_OneProperty_1=ruleOneProperty    {
1219                 $current.merge(this_OneProperty_1);
1220     }
1221
1222     {
1223         afterParserOrEnumRuleCall();
1224     }
1225 (
1226         kw=','
1227     {
1228         $current.merge(kw);
1229         newLeafNode(kw, grammarAccess.getPropertyAccess().getCommaKeyword_2_0());
1230     }
1231
1232     {
1233         newCompositeNode(grammarAccess.getPropertyAccess().getOnePropertyParserRuleCall_2_1());
1234     }
1235     this_OneProperty_3=ruleOneProperty    {
1236                 $current.merge(this_OneProperty_3);
1237     }
1238
1239     {
1240         afterParserOrEnumRuleCall();
1241     }
1242 )*)
1243     ;
1244
1245
1246
1247
1248
1249 // Entry rule entryRuleOneProperty
1250 entryRuleOneProperty returns [String current=null]
1251         :
1252         { newCompositeNode(grammarAccess.getOnePropertyRule()); }
1253          iv_ruleOneProperty=ruleOneProperty
1254          { $current=$iv_ruleOneProperty.current.getText(); }
1255          EOF
1256 ;
1257
1258 // Rule OneProperty
1259 ruleOneProperty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
1260     @init { enterRule();
1261     }
1262     @after { leaveRule(); }:
1263 (    this_NemoId_0=RULE_NEMOID    {
1264                 $current.merge(this_NemoId_0);
1265     }
1266
1267     {
1268     newLeafNode(this_NemoId_0, grammarAccess.getOnePropertyAccess().getNemoIdTerminalRuleCall_0());
1269     }
1270
1271         kw=':'
1272     {
1273         $current.merge(kw);
1274         newLeafNode(kw, grammarAccess.getOnePropertyAccess().getColonKeyword_1());
1275     }
1276 (    this_STRING_2=RULE_STRING    {
1277                 $current.merge(this_STRING_2);
1278     }
1279
1280     {
1281     newLeafNode(this_STRING_2, grammarAccess.getOnePropertyAccess().getSTRINGTerminalRuleCall_2_0());
1282     }
1283
1284     |    this_INT_3=RULE_INT    {
1285                 $current.merge(this_INT_3);
1286     }
1287
1288     {
1289     newLeafNode(this_INT_3, grammarAccess.getOnePropertyAccess().getINTTerminalRuleCall_2_1());
1290     }
1291 ))
1292     ;
1293
1294
1295
1296
1297
1298 // Entry rule entryRuleModelProperty
1299 entryRuleModelProperty returns [String current=null]
1300         :
1301         { newCompositeNode(grammarAccess.getModelPropertyRule()); }
1302          iv_ruleModelProperty=ruleModelProperty
1303          { $current=$iv_ruleModelProperty.current.getText(); }
1304          EOF
1305 ;
1306
1307 // Rule ModelProperty
1308 ruleModelProperty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
1309     @init { enterRule();
1310     }
1311     @after { leaveRule(); }:
1312 (
1313         kw='Property'
1314     {
1315         $current.merge(kw);
1316         newLeafNode(kw, grammarAccess.getModelPropertyAccess().getPropertyKeyword_0());
1317     }
1318
1319     {
1320         newCompositeNode(grammarAccess.getModelPropertyAccess().getOneModelPropertyParserRuleCall_1());
1321     }
1322     this_OneModelProperty_1=ruleOneModelProperty    {
1323                 $current.merge(this_OneModelProperty_1);
1324     }
1325
1326     {
1327         afterParserOrEnumRuleCall();
1328     }
1329 (
1330         kw=','
1331     {
1332         $current.merge(kw);
1333         newLeafNode(kw, grammarAccess.getModelPropertyAccess().getCommaKeyword_2_0());
1334     }
1335
1336     {
1337         newCompositeNode(grammarAccess.getModelPropertyAccess().getOneModelPropertyParserRuleCall_2_1());
1338     }
1339     this_OneModelProperty_3=ruleOneModelProperty    {
1340                 $current.merge(this_OneModelProperty_3);
1341     }
1342
1343     {
1344         afterParserOrEnumRuleCall();
1345     }
1346 )*)
1347     ;
1348
1349
1350
1351
1352
1353 // Entry rule entryRuleOneModelProperty
1354 entryRuleOneModelProperty returns [String current=null]
1355         :
1356         { newCompositeNode(grammarAccess.getOneModelPropertyRule()); }
1357          iv_ruleOneModelProperty=ruleOneModelProperty
1358          { $current=$iv_ruleOneModelProperty.current.getText(); }
1359          EOF
1360 ;
1361
1362 // Rule OneModelProperty
1363 ruleOneModelProperty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
1364     @init { enterRule();
1365     }
1366     @after { leaveRule(); }:
1367 ((    this_STRING_0=RULE_STRING    {
1368                 $current.merge(this_STRING_0);
1369     }
1370
1371     {
1372     newLeafNode(this_STRING_0, grammarAccess.getOneModelPropertyAccess().getSTRINGTerminalRuleCall_0_0());
1373     }
1374
1375     |    this_INT_1=RULE_INT    {
1376                 $current.merge(this_INT_1);
1377     }
1378
1379     {
1380     newLeafNode(this_INT_1, grammarAccess.getOneModelPropertyAccess().getINTTerminalRuleCall_0_1());
1381     }
1382 )
1383         kw=':'
1384     {
1385         $current.merge(kw);
1386         newLeafNode(kw, grammarAccess.getOneModelPropertyAccess().getColonKeyword_1());
1387     }
1388     this_NemoId_3=RULE_NEMOID    {
1389                 $current.merge(this_NemoId_3);
1390     }
1391
1392     {
1393     newLeafNode(this_NemoId_3, grammarAccess.getOneModelPropertyAccess().getNemoIdTerminalRuleCall_2());
1394     }
1395 )
1396     ;
1397
1398
1399
1400
1401
1402 // Entry rule entryRuleNewObj
1403 entryRuleNewObj returns [String current=null]
1404         :
1405         { newCompositeNode(grammarAccess.getNewObjRule()); }
1406          iv_ruleNewObj=ruleNewObj
1407          { $current=$iv_ruleNewObj.current.getText(); }
1408          EOF
1409 ;
1410
1411 // Rule NewObj
1412 ruleNewObj returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
1413     @init { enterRule();
1414     }
1415     @after { leaveRule(); }:
1416 (
1417         kw='CREATE'
1418     {
1419         $current.merge(kw);
1420         newLeafNode(kw, grammarAccess.getNewObjAccess().getCREATEKeyword_0());
1421     }
1422
1423     |
1424         kw='IMPORT'
1425     {
1426         $current.merge(kw);
1427         newLeafNode(kw, grammarAccess.getNewObjAccess().getIMPORTKeyword_1());
1428     }
1429 )
1430     ;
1431
1432
1433
1434
1435
1436 RULE_IPV4_SUB : ('0'..'9'|'1'..'9' '0'..'9'|'1' '0'..'9' '0'..'9'|'2' '0'..'4' '0'..'9'|'25' '0'..'5');
1437
1438 RULE_NEMOID : ('a'..'z'|'A'..'Z'|'$'|'_') ('a'..'z'|'A'..'Z'|'$'|'_'|'-'|'0'..'9')*;
1439
1440 RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*;
1441
1442 RULE_INT : ('0'..'9')+;
1443
1444 RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\'');
1445
1446 RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/';
1447
1448 RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?;
1449
1450 RULE_WS : (' '|'\t'|'\r'|'\n')+;
1451
1452 RULE_ANY_OTHER : .;
1453
1454