1 // $ANTLR 3.1.2 BuildOptions\\ProfileGrammar.g3 2009-09-30 13:18:17 2 3 // The variable 'variable' is assigned but its value is never used. 4 #pragma warning disable 219 5 // Unreachable code detected. 6 #pragma warning disable 162 7 8 9 using System.Collections.Generic; 10 using Antlr.Runtime; 11 using Stack = System.Collections.Generic.Stack<object>; 12 using List = System.Collections.IList; 13 using ArrayList = System.Collections.Generic.List<object>; 14 15 using Antlr.Runtime.Debug; 16 using IOException = System.IO.IOException; 17 18 using Antlr.Runtime.Tree; 19 using RewriteRuleITokenStream = Antlr.Runtime.Tree.RewriteRuleTokenStream; 20 21 [System.CodeDom.Compiler.GeneratedCode("ANTLR", "3.1.2")] 22 [System.CLSCompliant(false)] 23 public partial class ProfileGrammarParser : DebugParser 24 { 25 internal static readonly string[] tokenNames = new string[] { 26 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "CALL", "FUNC", "ID", "INT", "NEWLINE", "WS", "'-'", "'%'", "'('", "')'", "'*'", "'/'", "'+'", "'='" 27 }; 28 public const int EOF=-1; 29 public const int T__10=10; 30 public const int T__11=11; 31 public const int T__12=12; 32 public const int T__13=13; 33 public const int T__14=14; 34 public const int T__15=15; 35 public const int T__16=16; 36 public const int T__17=17; 37 public const int CALL=4; 38 public const int FUNC=5; 39 public const int ID=6; 40 public const int INT=7; 41 public const int NEWLINE=8; 42 public const int WS=9; 43 44 // delegates 45 // delegators 46 47 public static readonly string[] ruleNames = 48 new string[] 49 { 50 "invalidRule", "atom", "expr", "formalPar", "func", "multExpr", "prog", 51 "stat" 52 }; 53 54 int ruleLevel = 0; 55 public virtual int RuleLevel { get { return ruleLevel; } } IncRuleLevel()56 public virtual void IncRuleLevel() { ruleLevel++; } DecRuleLevel()57 public virtual void DecRuleLevel() { ruleLevel--; } ProfileGrammarParser( ITokenStream input )58 public ProfileGrammarParser( ITokenStream input ) 59 : this( input, new Profiler(null), new RecognizerSharedState() ) 60 { 61 } ProfileGrammarParser( ITokenStream input, IDebugEventListener dbg, RecognizerSharedState state )62 public ProfileGrammarParser( ITokenStream input, IDebugEventListener dbg, RecognizerSharedState state ) 63 : base( input, dbg, state ) 64 { 65 Profiler p = (Profiler)dbg; 66 p.setParser(this); 67 InitializeTreeAdaptor(); 68 if ( TreeAdaptor == null ) 69 TreeAdaptor = new CommonTreeAdaptor(); 70 ITreeAdaptor adap = new CommonTreeAdaptor(); 71 TreeAdaptor = adap; 72 proxy.TreeAdaptor = adap; 73 } 74 ProfileGrammarParser( ITokenStream input, IDebugEventListener dbg )75 public ProfileGrammarParser( ITokenStream input, IDebugEventListener dbg ) 76 : base( input, dbg ) 77 { 78 Profiler p = (Profiler)dbg; 79 p.setParser(this);InitializeTreeAdaptor(); 80 if ( TreeAdaptor == null ) 81 TreeAdaptor = new CommonTreeAdaptor(); 82 83 ITreeAdaptor adap = new CommonTreeAdaptor(); 84 TreeAdaptor = adap; 85 86 } AlreadyParsedRule( IIntStream input, int ruleIndex )87 public virtual bool AlreadyParsedRule( IIntStream input, int ruleIndex ) 88 { 89 ((Profiler)dbg).ExamineRuleMemoization(input, ruleIndex, ProfileGrammarParser.ruleNames[ruleIndex]); 90 return super.AlreadyParsedRule(input, ruleIndex); 91 } 92 Memoize( IIntStream input, int ruleIndex, int ruleStartIndex )93 public virtual void Memoize( IIntStream input, int ruleIndex, int ruleStartIndex ) 94 { 95 ((Profiler)dbg).Memoize(input, ruleIndex, ruleStartIndex, ProfileGrammarParser.ruleNames[ruleIndex]); 96 super.Memoize(input, ruleIndex, ruleStartIndex); 97 } EvalPredicate( bool result, string predicate )98 protected virtual bool EvalPredicate( bool result, string predicate ) 99 { 100 dbg.SemanticPredicate( result, predicate ); 101 return result; 102 } 103 104 // Implement this function in your helper file to use a custom tree adaptor InitializeTreeAdaptor()105 partial void InitializeTreeAdaptor(); 106 protected DebugTreeAdaptor adaptor; 107 108 public ITreeAdaptor TreeAdaptor 109 { 110 get 111 { 112 return adaptor; 113 } 114 set 115 { 116 this.adaptor = new DebugTreeAdaptor(dbg,adaptor); 117 118 } 119 } 120 121 122 public override string[] TokenNames { get { return ProfileGrammarParser.tokenNames; } } 123 public override string GrammarFileName { get { return "BuildOptions\\ProfileGrammar.g3"; } } 124 125 126 #region Rules 127 public class prog_return : ParserRuleReturnScope 128 { 129 internal CommonTree tree; 130 public override object Tree { get { return tree; } } 131 } 132 133 // $ANTLR start "prog" 134 // BuildOptions\\ProfileGrammar.g3:50:0: prog : ( stat )* ; prog( )135 private ProfileGrammarParser.prog_return prog( ) 136 { 137 ProfileGrammarParser.prog_return retval = new ProfileGrammarParser.prog_return(); 138 retval.start = input.LT(1); 139 140 CommonTree root_0 = null; 141 142 ProfileGrammarParser.stat_return stat1 = default(ProfileGrammarParser.stat_return); 143 144 145 try 146 { 147 dbg.EnterRule( GrammarFileName, "prog" ); 148 if ( RuleLevel == 0 ) 149 { 150 dbg.Commence(); 151 } 152 IncRuleLevel(); 153 dbg.Location( 50, -1 ); 154 155 try 156 { 157 // BuildOptions\\ProfileGrammar.g3:50:7: ( ( stat )* ) 158 dbg.EnterAlt( 1 ); 159 160 // BuildOptions\\ProfileGrammar.g3:50:7: ( stat )* 161 { 162 root_0 = (CommonTree)adaptor.Nil(); 163 164 dbg.Location( 50, 6 ); 165 // BuildOptions\\ProfileGrammar.g3:50:7: ( stat )* 166 try 167 { 168 dbg.EnterSubRule( 1 ); 169 170 for ( ; ; ) 171 { 172 int alt1=2; 173 try 174 { 175 dbg.EnterDecision( 1 ); 176 177 int LA1_0 = input.LA(1); 178 179 if ( ((LA1_0>=ID && LA1_0<=NEWLINE)||LA1_0==12) ) 180 { 181 alt1=1; 182 } 183 184 185 } 186 finally 187 { 188 dbg.ExitDecision( 1 ); 189 } 190 191 switch ( alt1 ) 192 { 193 case 1: 194 dbg.EnterAlt( 1 ); 195 196 // BuildOptions\\ProfileGrammar.g3:50:9: stat 197 { 198 dbg.Location( 50, 8 ); 199 PushFollow(Follow._stat_in_prog53); 200 stat1=stat(); 201 202 state._fsp--; 203 204 adaptor.AddChild(root_0, stat1.Tree); 205 206 } 207 break; 208 209 default: 210 goto loop1; 211 } 212 } 213 214 loop1: 215 ; 216 217 } 218 finally 219 { 220 dbg.ExitSubRule( 1 ); 221 } 222 223 224 } 225 226 retval.stop = input.LT(-1); 227 228 retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0); 229 adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop); 230 231 } 232 catch ( RecognitionException re ) 233 { 234 ReportError(re); 235 Recover(input,re); 236 retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re); 237 238 } 239 finally 240 { 241 } 242 dbg.Location(51, 4); 243 244 } 245 finally 246 { 247 dbg.ExitRule( GrammarFileName, "prog" ); 248 DecRuleLevel(); 249 if ( RuleLevel == 0 ) 250 { 251 dbg.Terminate(); 252 } 253 } 254 255 return retval; 256 } 257 // $ANTLR end "prog" 258 259 public class stat_return : ParserRuleReturnScope 260 { 261 internal CommonTree tree; 262 public override object Tree { get { return tree; } } 263 } 264 265 // $ANTLR start "stat" 266 // BuildOptions\\ProfileGrammar.g3:53:0: stat : ( expr NEWLINE -> expr | ID '=' expr NEWLINE -> ^( '=' ID expr ) | func NEWLINE -> func | NEWLINE ->); stat( )267 private ProfileGrammarParser.stat_return stat( ) 268 { 269 ProfileGrammarParser.stat_return retval = new ProfileGrammarParser.stat_return(); 270 retval.start = input.LT(1); 271 272 CommonTree root_0 = null; 273 274 IToken NEWLINE3=null; 275 IToken ID4=null; 276 IToken char_literal5=null; 277 IToken NEWLINE7=null; 278 IToken NEWLINE9=null; 279 IToken NEWLINE10=null; 280 ProfileGrammarParser.expr_return expr2 = default(ProfileGrammarParser.expr_return); 281 ProfileGrammarParser.expr_return expr6 = default(ProfileGrammarParser.expr_return); 282 ProfileGrammarParser.func_return func8 = default(ProfileGrammarParser.func_return); 283 284 CommonTree NEWLINE3_tree=null; 285 CommonTree ID4_tree=null; 286 CommonTree char_literal5_tree=null; 287 CommonTree NEWLINE7_tree=null; 288 CommonTree NEWLINE9_tree=null; 289 CommonTree NEWLINE10_tree=null; 290 RewriteRuleITokenStream stream_NEWLINE=new RewriteRuleITokenStream(adaptor,"token NEWLINE"); 291 RewriteRuleITokenStream stream_ID=new RewriteRuleITokenStream(adaptor,"token ID"); 292 RewriteRuleITokenStream stream_17=new RewriteRuleITokenStream(adaptor,"token 17"); 293 RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr"); 294 RewriteRuleSubtreeStream stream_func=new RewriteRuleSubtreeStream(adaptor,"rule func"); 295 try 296 { 297 dbg.EnterRule( GrammarFileName, "stat" ); 298 if ( RuleLevel == 0 ) 299 { 300 dbg.Commence(); 301 } 302 IncRuleLevel(); 303 dbg.Location( 53, -1 ); 304 305 try 306 { 307 // BuildOptions\\ProfileGrammar.g3:53:9: ( expr NEWLINE -> expr | ID '=' expr NEWLINE -> ^( '=' ID expr ) | func NEWLINE -> func | NEWLINE ->) 308 int alt2=4; 309 try 310 { 311 dbg.EnterDecision( 2 ); 312 313 try 314 { 315 isCyclicDecision = true; 316 alt2 = dfa2.Predict(input); 317 } 318 catch ( NoViableAltException nvae ) 319 { 320 dbg.RecognitionException( nvae ); 321 throw nvae; 322 } 323 } 324 finally 325 { 326 dbg.ExitDecision( 2 ); 327 } 328 329 switch ( alt2 ) 330 { 331 case 1: 332 dbg.EnterAlt( 1 ); 333 334 // BuildOptions\\ProfileGrammar.g3:53:9: expr NEWLINE 335 { 336 dbg.Location( 53, 8 ); 337 PushFollow(Follow._expr_in_stat70); 338 expr2=expr(); 339 340 state._fsp--; 341 342 stream_expr.Add(expr2.Tree); 343 dbg.Location( 53, 13 ); 344 NEWLINE3=(IToken)Match(input,NEWLINE,Follow._NEWLINE_in_stat72); 345 stream_NEWLINE.Add(NEWLINE3); 346 347 348 349 { 350 // AST REWRITE 351 // elements: expr 352 // token labels: 353 // rule labels: retval 354 // token list labels: 355 // rule list labels: 356 // wildcard labels: 357 retval.tree = root_0; 358 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); 359 360 root_0 = (CommonTree)adaptor.Nil(); 361 // 53:41: -> expr 362 { 363 dbg.Location( 53, 43 ); 364 adaptor.AddChild(root_0, stream_expr.NextTree()); 365 366 } 367 368 retval.tree = root_0; 369 } 370 371 } 372 break; 373 case 2: 374 dbg.EnterAlt( 2 ); 375 376 // BuildOptions\\ProfileGrammar.g3:54:9: ID '=' expr NEWLINE 377 { 378 dbg.Location( 54, 8 ); 379 ID4=(IToken)Match(input,ID,Follow._ID_in_stat105); 380 stream_ID.Add(ID4); 381 382 dbg.Location( 54, 11 ); 383 char_literal5=(IToken)Match(input,17,Follow._17_in_stat107); 384 stream_17.Add(char_literal5); 385 386 dbg.Location( 54, 15 ); 387 PushFollow(Follow._expr_in_stat109); 388 expr6=expr(); 389 390 state._fsp--; 391 392 stream_expr.Add(expr6.Tree); 393 dbg.Location( 54, 20 ); 394 NEWLINE7=(IToken)Match(input,NEWLINE,Follow._NEWLINE_in_stat111); 395 stream_NEWLINE.Add(NEWLINE7); 396 397 398 399 { 400 // AST REWRITE 401 // elements: 17, ID, expr 402 // token labels: 403 // rule labels: retval 404 // token list labels: 405 // rule list labels: 406 // wildcard labels: 407 retval.tree = root_0; 408 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); 409 410 root_0 = (CommonTree)adaptor.Nil(); 411 // 54:41: -> ^( '=' ID expr ) 412 { 413 dbg.Location( 54, 43 ); 414 // BuildOptions\\ProfileGrammar.g3:54:44: ^( '=' ID expr ) 415 { 416 CommonTree root_1 = (CommonTree)adaptor.Nil(); 417 dbg.Location( 54, 45 ); 418 root_1 = (CommonTree)adaptor.BecomeRoot(stream_17.NextNode(), root_1); 419 420 dbg.Location( 54, 49 ); 421 adaptor.AddChild(root_1, stream_ID.NextNode()); 422 dbg.Location( 54, 52 ); 423 adaptor.AddChild(root_1, stream_expr.NextTree()); 424 425 adaptor.AddChild(root_0, root_1); 426 } 427 428 } 429 430 retval.tree = root_0; 431 } 432 433 } 434 break; 435 case 3: 436 dbg.EnterAlt( 3 ); 437 438 // BuildOptions\\ProfileGrammar.g3:55:9: func NEWLINE 439 { 440 dbg.Location( 55, 8 ); 441 PushFollow(Follow._func_in_stat143); 442 func8=func(); 443 444 state._fsp--; 445 446 stream_func.Add(func8.Tree); 447 dbg.Location( 55, 13 ); 448 NEWLINE9=(IToken)Match(input,NEWLINE,Follow._NEWLINE_in_stat145); 449 stream_NEWLINE.Add(NEWLINE9); 450 451 452 453 { 454 // AST REWRITE 455 // elements: func 456 // token labels: 457 // rule labels: retval 458 // token list labels: 459 // rule list labels: 460 // wildcard labels: 461 retval.tree = root_0; 462 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); 463 464 root_0 = (CommonTree)adaptor.Nil(); 465 // 55:41: -> func 466 { 467 dbg.Location( 55, 43 ); 468 adaptor.AddChild(root_0, stream_func.NextTree()); 469 470 } 471 472 retval.tree = root_0; 473 } 474 475 } 476 break; 477 case 4: 478 dbg.EnterAlt( 4 ); 479 480 // BuildOptions\\ProfileGrammar.g3:56:9: NEWLINE 481 { 482 dbg.Location( 56, 8 ); 483 NEWLINE10=(IToken)Match(input,NEWLINE,Follow._NEWLINE_in_stat178); 484 stream_NEWLINE.Add(NEWLINE10); 485 486 487 488 { 489 // AST REWRITE 490 // elements: 491 // token labels: 492 // rule labels: retval 493 // token list labels: 494 // rule list labels: 495 // wildcard labels: 496 retval.tree = root_0; 497 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); 498 499 root_0 = (CommonTree)adaptor.Nil(); 500 // 56:41: -> 501 { 502 dbg.Location( 57, 4 ); 503 root_0 = null; 504 } 505 506 retval.tree = root_0; 507 } 508 509 } 510 break; 511 512 } 513 retval.stop = input.LT(-1); 514 515 retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0); 516 adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop); 517 518 } 519 catch ( RecognitionException re ) 520 { 521 ReportError(re); 522 Recover(input,re); 523 retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re); 524 525 } 526 finally 527 { 528 } 529 dbg.Location(57, 4); 530 531 } 532 finally 533 { 534 dbg.ExitRule( GrammarFileName, "stat" ); 535 DecRuleLevel(); 536 if ( RuleLevel == 0 ) 537 { 538 dbg.Terminate(); 539 } 540 } 541 542 return retval; 543 } 544 // $ANTLR end "stat" 545 546 public class func_return : ParserRuleReturnScope 547 { 548 internal CommonTree tree; 549 public override object Tree { get { return tree; } } 550 } 551 552 // $ANTLR start "func" 553 // BuildOptions\\ProfileGrammar.g3:59:0: func : ID '(' formalPar ')' '=' expr -> ^( FUNC ID formalPar expr ) ; func( )554 private ProfileGrammarParser.func_return func( ) 555 { 556 ProfileGrammarParser.func_return retval = new ProfileGrammarParser.func_return(); 557 retval.start = input.LT(1); 558 559 CommonTree root_0 = null; 560 561 IToken ID11=null; 562 IToken char_literal12=null; 563 IToken char_literal14=null; 564 IToken char_literal15=null; 565 ProfileGrammarParser.formalPar_return formalPar13 = default(ProfileGrammarParser.formalPar_return); 566 ProfileGrammarParser.expr_return expr16 = default(ProfileGrammarParser.expr_return); 567 568 CommonTree ID11_tree=null; 569 CommonTree char_literal12_tree=null; 570 CommonTree char_literal14_tree=null; 571 CommonTree char_literal15_tree=null; 572 RewriteRuleITokenStream stream_ID=new RewriteRuleITokenStream(adaptor,"token ID"); 573 RewriteRuleITokenStream stream_12=new RewriteRuleITokenStream(adaptor,"token 12"); 574 RewriteRuleITokenStream stream_13=new RewriteRuleITokenStream(adaptor,"token 13"); 575 RewriteRuleITokenStream stream_17=new RewriteRuleITokenStream(adaptor,"token 17"); 576 RewriteRuleSubtreeStream stream_formalPar=new RewriteRuleSubtreeStream(adaptor,"rule formalPar"); 577 RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr"); 578 try 579 { 580 dbg.EnterRule( GrammarFileName, "func" ); 581 if ( RuleLevel == 0 ) 582 { 583 dbg.Commence(); 584 } 585 IncRuleLevel(); 586 dbg.Location( 59, -1 ); 587 588 try 589 { 590 // BuildOptions\\ProfileGrammar.g3:59:9: ( ID '(' formalPar ')' '=' expr -> ^( FUNC ID formalPar expr ) ) 591 dbg.EnterAlt( 1 ); 592 593 // BuildOptions\\ProfileGrammar.g3:59:9: ID '(' formalPar ')' '=' expr 594 { 595 dbg.Location( 59, 8 ); 596 ID11=(IToken)Match(input,ID,Follow._ID_in_func219); 597 stream_ID.Add(ID11); 598 599 dbg.Location( 59, 12 ); 600 char_literal12=(IToken)Match(input,12,Follow._12_in_func222); 601 stream_12.Add(char_literal12); 602 603 dbg.Location( 59, 16 ); 604 PushFollow(Follow._formalPar_in_func224); 605 formalPar13=formalPar(); 606 607 state._fsp--; 608 609 stream_formalPar.Add(formalPar13.Tree); 610 dbg.Location( 59, 26 ); 611 char_literal14=(IToken)Match(input,13,Follow._13_in_func226); 612 stream_13.Add(char_literal14); 613 614 dbg.Location( 59, 30 ); 615 char_literal15=(IToken)Match(input,17,Follow._17_in_func228); 616 stream_17.Add(char_literal15); 617 618 dbg.Location( 59, 34 ); 619 PushFollow(Follow._expr_in_func230); 620 expr16=expr(); 621 622 state._fsp--; 623 624 stream_expr.Add(expr16.Tree); 625 626 627 { 628 // AST REWRITE 629 // elements: ID, formalPar, expr 630 // token labels: 631 // rule labels: retval 632 // token list labels: 633 // rule list labels: 634 // wildcard labels: 635 retval.tree = root_0; 636 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); 637 638 root_0 = (CommonTree)adaptor.Nil(); 639 // 59:41: -> ^( FUNC ID formalPar expr ) 640 { 641 dbg.Location( 59, 43 ); 642 // BuildOptions\\ProfileGrammar.g3:59:44: ^( FUNC ID formalPar expr ) 643 { 644 CommonTree root_1 = (CommonTree)adaptor.Nil(); 645 dbg.Location( 59, 45 ); 646 root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(FUNC, "FUNC"), root_1); 647 648 dbg.Location( 59, 50 ); 649 adaptor.AddChild(root_1, stream_ID.NextNode()); 650 dbg.Location( 59, 53 ); 651 adaptor.AddChild(root_1, stream_formalPar.NextTree()); 652 dbg.Location( 59, 63 ); 653 adaptor.AddChild(root_1, stream_expr.NextTree()); 654 655 adaptor.AddChild(root_0, root_1); 656 } 657 658 } 659 660 retval.tree = root_0; 661 } 662 663 } 664 665 retval.stop = input.LT(-1); 666 667 retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0); 668 adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop); 669 670 } 671 catch ( RecognitionException re ) 672 { 673 ReportError(re); 674 Recover(input,re); 675 retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re); 676 677 } 678 finally 679 { 680 681 functionDefinitions.Add(((CommonTree)retval.Tree)); 682 683 } 684 dbg.Location(60, 4); 685 686 } 687 finally 688 { 689 dbg.ExitRule( GrammarFileName, "func" ); 690 DecRuleLevel(); 691 if ( RuleLevel == 0 ) 692 { 693 dbg.Terminate(); 694 } 695 } 696 697 return retval; 698 } 699 // $ANTLR end "func" 700 701 public class formalPar_return : ParserRuleReturnScope 702 { 703 internal CommonTree tree; 704 public override object Tree { get { return tree; } } 705 } 706 707 // $ANTLR start "formalPar" 708 // BuildOptions\\ProfileGrammar.g3:65:0: formalPar : ( ID | INT ); formalPar( )709 private ProfileGrammarParser.formalPar_return formalPar( ) 710 { 711 ProfileGrammarParser.formalPar_return retval = new ProfileGrammarParser.formalPar_return(); 712 retval.start = input.LT(1); 713 714 CommonTree root_0 = null; 715 716 IToken set17=null; 717 718 CommonTree set17_tree=null; 719 720 try 721 { 722 dbg.EnterRule( GrammarFileName, "formalPar" ); 723 if ( RuleLevel == 0 ) 724 { 725 dbg.Commence(); 726 } 727 IncRuleLevel(); 728 dbg.Location( 65, -1 ); 729 730 try 731 { 732 // BuildOptions\\ProfileGrammar.g3:66:9: ( ID | INT ) 733 dbg.EnterAlt( 1 ); 734 735 // BuildOptions\\ProfileGrammar.g3: 736 { 737 root_0 = (CommonTree)adaptor.Nil(); 738 739 dbg.Location( 66, 8 ); 740 set17=(IToken)input.LT(1); 741 if ( (input.LA(1)>=ID && input.LA(1)<=INT) ) 742 { 743 input.Consume(); 744 adaptor.AddChild(root_0, (CommonTree)adaptor.Create(set17)); 745 state.errorRecovery=false; 746 } 747 else 748 { 749 MismatchedSetException mse = new MismatchedSetException(null,input); 750 dbg.RecognitionException( mse ); 751 throw mse; 752 } 753 754 755 } 756 757 retval.stop = input.LT(-1); 758 759 retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0); 760 adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop); 761 762 } 763 catch ( RecognitionException re ) 764 { 765 ReportError(re); 766 Recover(input,re); 767 retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re); 768 769 } 770 finally 771 { 772 } 773 dbg.Location(68, 1); 774 775 } 776 finally 777 { 778 dbg.ExitRule( GrammarFileName, "formalPar" ); 779 DecRuleLevel(); 780 if ( RuleLevel == 0 ) 781 { 782 dbg.Terminate(); 783 } 784 } 785 786 return retval; 787 } 788 // $ANTLR end "formalPar" 789 790 public class expr_return : ParserRuleReturnScope 791 { 792 internal CommonTree tree; 793 public override object Tree { get { return tree; } } 794 } 795 796 // $ANTLR start "expr" 797 // BuildOptions\\ProfileGrammar.g3:73:0: expr : multExpr ( ( '+' | '-' ) multExpr )* ; expr( )798 private ProfileGrammarParser.expr_return expr( ) 799 { 800 ProfileGrammarParser.expr_return retval = new ProfileGrammarParser.expr_return(); 801 retval.start = input.LT(1); 802 803 CommonTree root_0 = null; 804 805 IToken char_literal19=null; 806 IToken char_literal20=null; 807 ProfileGrammarParser.multExpr_return multExpr18 = default(ProfileGrammarParser.multExpr_return); 808 ProfileGrammarParser.multExpr_return multExpr21 = default(ProfileGrammarParser.multExpr_return); 809 810 CommonTree char_literal19_tree=null; 811 CommonTree char_literal20_tree=null; 812 813 try 814 { 815 dbg.EnterRule( GrammarFileName, "expr" ); 816 if ( RuleLevel == 0 ) 817 { 818 dbg.Commence(); 819 } 820 IncRuleLevel(); 821 dbg.Location( 73, -1 ); 822 823 try 824 { 825 // BuildOptions\\ProfileGrammar.g3:73:9: ( multExpr ( ( '+' | '-' ) multExpr )* ) 826 dbg.EnterAlt( 1 ); 827 828 // BuildOptions\\ProfileGrammar.g3:73:9: multExpr ( ( '+' | '-' ) multExpr )* 829 { 830 root_0 = (CommonTree)adaptor.Nil(); 831 832 dbg.Location( 73, 8 ); 833 PushFollow(Follow._multExpr_in_expr288); 834 multExpr18=multExpr(); 835 836 state._fsp--; 837 838 adaptor.AddChild(root_0, multExpr18.Tree); 839 dbg.Location( 73, 17 ); 840 // BuildOptions\\ProfileGrammar.g3:73:18: ( ( '+' | '-' ) multExpr )* 841 try 842 { 843 dbg.EnterSubRule( 4 ); 844 845 for ( ; ; ) 846 { 847 int alt4=2; 848 try 849 { 850 dbg.EnterDecision( 4 ); 851 852 int LA4_0 = input.LA(1); 853 854 if ( (LA4_0==10||LA4_0==16) ) 855 { 856 alt4=1; 857 } 858 859 860 } 861 finally 862 { 863 dbg.ExitDecision( 4 ); 864 } 865 866 switch ( alt4 ) 867 { 868 case 1: 869 dbg.EnterAlt( 1 ); 870 871 // BuildOptions\\ProfileGrammar.g3:73:19: ( '+' | '-' ) multExpr 872 { 873 dbg.Location( 73, 18 ); 874 // BuildOptions\\ProfileGrammar.g3:73:19: ( '+' | '-' ) 875 int alt3=2; 876 try 877 { 878 dbg.EnterSubRule( 3 ); 879 try 880 { 881 dbg.EnterDecision( 3 ); 882 883 int LA3_0 = input.LA(1); 884 885 if ( (LA3_0==16) ) 886 { 887 alt3=1; 888 } 889 else if ( (LA3_0==10) ) 890 { 891 alt3=2; 892 } 893 else 894 { 895 NoViableAltException nvae = new NoViableAltException("", 3, 0, input); 896 897 dbg.RecognitionException( nvae ); 898 throw nvae; 899 } 900 } 901 finally 902 { 903 dbg.ExitDecision( 3 ); 904 } 905 906 switch ( alt3 ) 907 { 908 case 1: 909 dbg.EnterAlt( 1 ); 910 911 // BuildOptions\\ProfileGrammar.g3:73:20: '+' 912 { 913 dbg.Location( 73, 22 ); 914 char_literal19=(IToken)Match(input,16,Follow._16_in_expr292); 915 char_literal19_tree = (CommonTree)adaptor.Create(char_literal19); 916 root_0 = (CommonTree)adaptor.BecomeRoot(char_literal19_tree, root_0); 917 918 919 } 920 break; 921 case 2: 922 dbg.EnterAlt( 2 ); 923 924 // BuildOptions\\ProfileGrammar.g3:73:25: '-' 925 { 926 dbg.Location( 73, 27 ); 927 char_literal20=(IToken)Match(input,10,Follow._10_in_expr295); 928 char_literal20_tree = (CommonTree)adaptor.Create(char_literal20); 929 root_0 = (CommonTree)adaptor.BecomeRoot(char_literal20_tree, root_0); 930 931 932 } 933 break; 934 935 } 936 } 937 finally 938 { 939 dbg.ExitSubRule( 3 ); 940 } 941 942 dbg.Location( 73, 30 ); 943 PushFollow(Follow._multExpr_in_expr299); 944 multExpr21=multExpr(); 945 946 state._fsp--; 947 948 adaptor.AddChild(root_0, multExpr21.Tree); 949 950 } 951 break; 952 953 default: 954 goto loop4; 955 } 956 } 957 958 loop4: 959 ; 960 961 } 962 finally 963 { 964 dbg.ExitSubRule( 4 ); 965 } 966 967 968 } 969 970 retval.stop = input.LT(-1); 971 972 retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0); 973 adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop); 974 975 } 976 catch ( RecognitionException re ) 977 { 978 ReportError(re); 979 Recover(input,re); 980 retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re); 981 982 } 983 finally 984 { 985 } 986 dbg.Location(74, 4); 987 988 } 989 finally 990 { 991 dbg.ExitRule( GrammarFileName, "expr" ); 992 DecRuleLevel(); 993 if ( RuleLevel == 0 ) 994 { 995 dbg.Terminate(); 996 } 997 } 998 999 return retval; 1000 } 1001 // $ANTLR end "expr" 1002 1003 public class multExpr_return : ParserRuleReturnScope 1004 { 1005 internal CommonTree tree; 1006 public override object Tree { get { return tree; } } 1007 } 1008 1009 // $ANTLR start "multExpr" 1010 // BuildOptions\\ProfileGrammar.g3:76:0: multExpr : atom ( ( '*' | '/' | '%' ) atom )* ; multExpr( )1011 private ProfileGrammarParser.multExpr_return multExpr( ) 1012 { 1013 ProfileGrammarParser.multExpr_return retval = new ProfileGrammarParser.multExpr_return(); 1014 retval.start = input.LT(1); 1015 1016 CommonTree root_0 = null; 1017 1018 IToken set23=null; 1019 ProfileGrammarParser.atom_return atom22 = default(ProfileGrammarParser.atom_return); 1020 ProfileGrammarParser.atom_return atom24 = default(ProfileGrammarParser.atom_return); 1021 1022 CommonTree set23_tree=null; 1023 1024 try 1025 { 1026 dbg.EnterRule( GrammarFileName, "multExpr" ); 1027 if ( RuleLevel == 0 ) 1028 { 1029 dbg.Commence(); 1030 } 1031 IncRuleLevel(); 1032 dbg.Location( 76, -1 ); 1033 1034 try 1035 { 1036 // BuildOptions\\ProfileGrammar.g3:77:9: ( atom ( ( '*' | '/' | '%' ) atom )* ) 1037 dbg.EnterAlt( 1 ); 1038 1039 // BuildOptions\\ProfileGrammar.g3:77:9: atom ( ( '*' | '/' | '%' ) atom )* 1040 { 1041 root_0 = (CommonTree)adaptor.Nil(); 1042 1043 dbg.Location( 77, 8 ); 1044 PushFollow(Follow._atom_in_multExpr320); 1045 atom22=atom(); 1046 1047 state._fsp--; 1048 1049 adaptor.AddChild(root_0, atom22.Tree); 1050 dbg.Location( 77, 13 ); 1051 // BuildOptions\\ProfileGrammar.g3:77:14: ( ( '*' | '/' | '%' ) atom )* 1052 try 1053 { 1054 dbg.EnterSubRule( 5 ); 1055 1056 for ( ; ; ) 1057 { 1058 int alt5=2; 1059 try 1060 { 1061 dbg.EnterDecision( 5 ); 1062 1063 int LA5_0 = input.LA(1); 1064 1065 if ( (LA5_0==11||(LA5_0>=14 && LA5_0<=15)) ) 1066 { 1067 alt5=1; 1068 } 1069 1070 1071 } 1072 finally 1073 { 1074 dbg.ExitDecision( 5 ); 1075 } 1076 1077 switch ( alt5 ) 1078 { 1079 case 1: 1080 dbg.EnterAlt( 1 ); 1081 1082 // BuildOptions\\ProfileGrammar.g3:77:15: ( '*' | '/' | '%' ) atom 1083 { 1084 dbg.Location( 77, 27 ); 1085 set23=(IToken)input.LT(1); 1086 set23=(IToken)input.LT(1); 1087 if ( input.LA(1)==11||(input.LA(1)>=14 && input.LA(1)<=15) ) 1088 { 1089 input.Consume(); 1090 root_0 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(set23), root_0); 1091 state.errorRecovery=false; 1092 } 1093 else 1094 { 1095 MismatchedSetException mse = new MismatchedSetException(null,input); 1096 dbg.RecognitionException( mse ); 1097 throw mse; 1098 } 1099 1100 dbg.Location( 77, 29 ); 1101 PushFollow(Follow._atom_in_multExpr332); 1102 atom24=atom(); 1103 1104 state._fsp--; 1105 1106 adaptor.AddChild(root_0, atom24.Tree); 1107 1108 } 1109 break; 1110 1111 default: 1112 goto loop5; 1113 } 1114 } 1115 1116 loop5: 1117 ; 1118 1119 } 1120 finally 1121 { 1122 dbg.ExitSubRule( 5 ); 1123 } 1124 1125 1126 } 1127 1128 retval.stop = input.LT(-1); 1129 1130 retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0); 1131 adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop); 1132 1133 } 1134 catch ( RecognitionException re ) 1135 { 1136 ReportError(re); 1137 Recover(input,re); 1138 retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re); 1139 1140 } 1141 finally 1142 { 1143 } 1144 dbg.Location(78, 4); 1145 1146 } 1147 finally 1148 { 1149 dbg.ExitRule( GrammarFileName, "multExpr" ); 1150 DecRuleLevel(); 1151 if ( RuleLevel == 0 ) 1152 { 1153 dbg.Terminate(); 1154 } 1155 } 1156 1157 return retval; 1158 } 1159 // $ANTLR end "multExpr" 1160 1161 public class atom_return : ParserRuleReturnScope 1162 { 1163 internal CommonTree tree; 1164 public override object Tree { get { return tree; } } 1165 } 1166 1167 // $ANTLR start "atom" 1168 // BuildOptions\\ProfileGrammar.g3:80:0: atom : ( INT | ID | '(' expr ')' -> expr | ID '(' expr ')' -> ^( CALL ID expr ) ); atom( )1169 private ProfileGrammarParser.atom_return atom( ) 1170 { 1171 ProfileGrammarParser.atom_return retval = new ProfileGrammarParser.atom_return(); 1172 retval.start = input.LT(1); 1173 1174 CommonTree root_0 = null; 1175 1176 IToken INT25=null; 1177 IToken ID26=null; 1178 IToken char_literal27=null; 1179 IToken char_literal29=null; 1180 IToken ID30=null; 1181 IToken char_literal31=null; 1182 IToken char_literal33=null; 1183 ProfileGrammarParser.expr_return expr28 = default(ProfileGrammarParser.expr_return); 1184 ProfileGrammarParser.expr_return expr32 = default(ProfileGrammarParser.expr_return); 1185 1186 CommonTree INT25_tree=null; 1187 CommonTree ID26_tree=null; 1188 CommonTree char_literal27_tree=null; 1189 CommonTree char_literal29_tree=null; 1190 CommonTree ID30_tree=null; 1191 CommonTree char_literal31_tree=null; 1192 CommonTree char_literal33_tree=null; 1193 RewriteRuleITokenStream stream_12=new RewriteRuleITokenStream(adaptor,"token 12"); 1194 RewriteRuleITokenStream stream_13=new RewriteRuleITokenStream(adaptor,"token 13"); 1195 RewriteRuleITokenStream stream_ID=new RewriteRuleITokenStream(adaptor,"token ID"); 1196 RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr"); 1197 try 1198 { 1199 dbg.EnterRule( GrammarFileName, "atom" ); 1200 if ( RuleLevel == 0 ) 1201 { 1202 dbg.Commence(); 1203 } 1204 IncRuleLevel(); 1205 dbg.Location( 80, -1 ); 1206 1207 try 1208 { 1209 // BuildOptions\\ProfileGrammar.g3:80:9: ( INT | ID | '(' expr ')' -> expr | ID '(' expr ')' -> ^( CALL ID expr ) ) 1210 int alt6=4; 1211 try 1212 { 1213 dbg.EnterDecision( 6 ); 1214 1215 switch ( input.LA(1) ) 1216 { 1217 case INT: 1218 { 1219 alt6=1; 1220 } 1221 break; 1222 case ID: 1223 { 1224 int LA6_2 = input.LA(2); 1225 1226 if ( (LA6_2==12) ) 1227 { 1228 alt6=4; 1229 } 1230 else if ( (LA6_2==NEWLINE||(LA6_2>=10 && LA6_2<=11)||(LA6_2>=13 && LA6_2<=16)) ) 1231 { 1232 alt6=2; 1233 } 1234 else 1235 { 1236 NoViableAltException nvae = new NoViableAltException("", 6, 2, input); 1237 1238 dbg.RecognitionException( nvae ); 1239 throw nvae; 1240 } 1241 } 1242 break; 1243 case 12: 1244 { 1245 alt6=3; 1246 } 1247 break; 1248 default: 1249 { 1250 NoViableAltException nvae = new NoViableAltException("", 6, 0, input); 1251 1252 dbg.RecognitionException( nvae ); 1253 throw nvae; 1254 } 1255 } 1256 1257 } 1258 finally 1259 { 1260 dbg.ExitDecision( 6 ); 1261 } 1262 1263 switch ( alt6 ) 1264 { 1265 case 1: 1266 dbg.EnterAlt( 1 ); 1267 1268 // BuildOptions\\ProfileGrammar.g3:80:9: INT 1269 { 1270 root_0 = (CommonTree)adaptor.Nil(); 1271 1272 dbg.Location( 80, 8 ); 1273 INT25=(IToken)Match(input,INT,Follow._INT_in_atom348); 1274 INT25_tree = (CommonTree)adaptor.Create(INT25); 1275 adaptor.AddChild(root_0, INT25_tree); 1276 1277 1278 } 1279 break; 1280 case 2: 1281 dbg.EnterAlt( 2 ); 1282 1283 // BuildOptions\\ProfileGrammar.g3:81:9: ID 1284 { 1285 root_0 = (CommonTree)adaptor.Nil(); 1286 1287 dbg.Location( 81, 8 ); 1288 ID26=(IToken)Match(input,ID,Follow._ID_in_atom358); 1289 ID26_tree = (CommonTree)adaptor.Create(ID26); 1290 adaptor.AddChild(root_0, ID26_tree); 1291 1292 1293 } 1294 break; 1295 case 3: 1296 dbg.EnterAlt( 3 ); 1297 1298 // BuildOptions\\ProfileGrammar.g3:82:9: '(' expr ')' 1299 { 1300 dbg.Location( 82, 8 ); 1301 char_literal27=(IToken)Match(input,12,Follow._12_in_atom368); 1302 stream_12.Add(char_literal27); 1303 1304 dbg.Location( 82, 12 ); 1305 PushFollow(Follow._expr_in_atom370); 1306 expr28=expr(); 1307 1308 state._fsp--; 1309 1310 stream_expr.Add(expr28.Tree); 1311 dbg.Location( 82, 17 ); 1312 char_literal29=(IToken)Match(input,13,Follow._13_in_atom372); 1313 stream_13.Add(char_literal29); 1314 1315 1316 1317 { 1318 // AST REWRITE 1319 // elements: expr 1320 // token labels: 1321 // rule labels: retval 1322 // token list labels: 1323 // rule list labels: 1324 // wildcard labels: 1325 retval.tree = root_0; 1326 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); 1327 1328 root_0 = (CommonTree)adaptor.Nil(); 1329 // 82:25: -> expr 1330 { 1331 dbg.Location( 82, 27 ); 1332 adaptor.AddChild(root_0, stream_expr.NextTree()); 1333 1334 } 1335 1336 retval.tree = root_0; 1337 } 1338 1339 } 1340 break; 1341 case 4: 1342 dbg.EnterAlt( 4 ); 1343 1344 // BuildOptions\\ProfileGrammar.g3:83:9: ID '(' expr ')' 1345 { 1346 dbg.Location( 83, 8 ); 1347 ID30=(IToken)Match(input,ID,Follow._ID_in_atom389); 1348 stream_ID.Add(ID30); 1349 1350 dbg.Location( 83, 11 ); 1351 char_literal31=(IToken)Match(input,12,Follow._12_in_atom391); 1352 stream_12.Add(char_literal31); 1353 1354 dbg.Location( 83, 15 ); 1355 PushFollow(Follow._expr_in_atom393); 1356 expr32=expr(); 1357 1358 state._fsp--; 1359 1360 stream_expr.Add(expr32.Tree); 1361 dbg.Location( 83, 20 ); 1362 char_literal33=(IToken)Match(input,13,Follow._13_in_atom395); 1363 stream_13.Add(char_literal33); 1364 1365 1366 1367 { 1368 // AST REWRITE 1369 // elements: ID, expr 1370 // token labels: 1371 // rule labels: retval 1372 // token list labels: 1373 // rule list labels: 1374 // wildcard labels: 1375 retval.tree = root_0; 1376 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); 1377 1378 root_0 = (CommonTree)adaptor.Nil(); 1379 // 83:25: -> ^( CALL ID expr ) 1380 { 1381 dbg.Location( 83, 27 ); 1382 // BuildOptions\\ProfileGrammar.g3:83:28: ^( CALL ID expr ) 1383 { 1384 CommonTree root_1 = (CommonTree)adaptor.Nil(); 1385 dbg.Location( 83, 29 ); 1386 root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CALL, "CALL"), root_1); 1387 1388 dbg.Location( 83, 34 ); 1389 adaptor.AddChild(root_1, stream_ID.NextNode()); 1390 dbg.Location( 83, 37 ); 1391 adaptor.AddChild(root_1, stream_expr.NextTree()); 1392 1393 adaptor.AddChild(root_0, root_1); 1394 } 1395 1396 } 1397 1398 retval.tree = root_0; 1399 } 1400 1401 } 1402 break; 1403 1404 } 1405 retval.stop = input.LT(-1); 1406 1407 retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0); 1408 adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop); 1409 1410 } 1411 catch ( RecognitionException re ) 1412 { 1413 ReportError(re); 1414 Recover(input,re); 1415 retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re); 1416 1417 } 1418 finally 1419 { 1420 } 1421 dbg.Location(84, 4); 1422 1423 } 1424 finally 1425 { 1426 dbg.ExitRule( GrammarFileName, "atom" ); 1427 DecRuleLevel(); 1428 if ( RuleLevel == 0 ) 1429 { 1430 dbg.Terminate(); 1431 } 1432 } 1433 1434 return retval; 1435 } 1436 // $ANTLR end "atom" 1437 #endregion Rules 1438 1439 1440 #region DFA 1441 DFA2 dfa2; 1442 InitDFAs()1443 protected override void InitDFAs() 1444 { 1445 base.InitDFAs(); 1446 dfa2 = new DFA2( this ); 1447 } 1448 1449 class DFA2 : DFA 1450 { 1451 1452 const string DFA2_eotS = 1453 "\xA\xFFFF"; 1454 const string DFA2_eofS = 1455 "\xA\xFFFF"; 1456 const string DFA2_minS = 1457 "\x1\x6\x1\xFFFF\x1\x8\x1\xFFFF\x1\x6\x1\xFFFF\x2\xA\x1\x8\x1\xFFFF"; 1458 const string DFA2_maxS = 1459 "\x1\xC\x1\xFFFF\x1\x11\x1\xFFFF\x1\xC\x1\xFFFF\x2\x10\x1\x11\x1\xFFFF"; 1460 const string DFA2_acceptS = 1461 "\x1\xFFFF\x1\x1\x1\xFFFF\x1\x4\x1\xFFFF\x1\x2\x3\xFFFF\x1\x3"; 1462 const string DFA2_specialS = 1463 "\xA\xFFFF}>"; 1464 static readonly string[] DFA2_transitionS = 1465 { 1466 "\x1\x2\x1\x1\x1\x3\x3\xFFFF\x1\x1", 1467 "", 1468 "\x1\x1\x1\xFFFF\x2\x1\x1\x4\x1\xFFFF\x3\x1\x1\x5", 1469 "", 1470 "\x1\x7\x1\x6\x4\xFFFF\x1\x1", 1471 "", 1472 "\x2\x1\x1\xFFFF\x1\x8\x3\x1", 1473 "\x3\x1\x1\x8\x3\x1", 1474 "\x1\x1\x1\xFFFF\x2\x1\x2\xFFFF\x3\x1\x1\x9", 1475 "" 1476 }; 1477 1478 static readonly short[] DFA2_eot = DFA.UnpackEncodedString(DFA2_eotS); 1479 static readonly short[] DFA2_eof = DFA.UnpackEncodedString(DFA2_eofS); 1480 static readonly char[] DFA2_min = DFA.UnpackEncodedStringToUnsignedChars(DFA2_minS); 1481 static readonly char[] DFA2_max = DFA.UnpackEncodedStringToUnsignedChars(DFA2_maxS); 1482 static readonly short[] DFA2_accept = DFA.UnpackEncodedString(DFA2_acceptS); 1483 static readonly short[] DFA2_special = DFA.UnpackEncodedString(DFA2_specialS); 1484 static readonly short[][] DFA2_transition; 1485 DFA2()1486 static DFA2() 1487 { 1488 int numStates = DFA2_transitionS.Length; 1489 DFA2_transition = new short[numStates][]; 1490 for ( int i=0; i < numStates; i++ ) 1491 { 1492 DFA2_transition[i] = DFA.UnpackEncodedString(DFA2_transitionS[i]); 1493 } 1494 } 1495 DFA2( BaseRecognizer recognizer )1496 public DFA2( BaseRecognizer recognizer ) 1497 { 1498 this.recognizer = recognizer; 1499 this.decisionNumber = 2; 1500 this.eot = DFA2_eot; 1501 this.eof = DFA2_eof; 1502 this.min = DFA2_min; 1503 this.max = DFA2_max; 1504 this.accept = DFA2_accept; 1505 this.special = DFA2_special; 1506 this.transition = DFA2_transition; 1507 } GetDescription()1508 public override string GetDescription() 1509 { 1510 return "53:0: stat : ( expr NEWLINE -> expr | ID '=' expr NEWLINE -> ^( '=' ID expr ) | func NEWLINE -> func | NEWLINE ->);"; 1511 } Error( NoViableAltException nvae )1512 public override void Error( NoViableAltException nvae ) 1513 { 1514 ((DebugParser)recognizer).dbg.RecognitionException( nvae ); 1515 } 1516 } 1517 1518 1519 #endregion DFA 1520 1521 #region Follow sets 1522 private static class Follow 1523 { 1524 public static readonly BitSet _stat_in_prog53 = new BitSet(new ulong[]{0x11C2UL}); 1525 public static readonly BitSet _expr_in_stat70 = new BitSet(new ulong[]{0x100UL}); 1526 public static readonly BitSet _NEWLINE_in_stat72 = new BitSet(new ulong[]{0x2UL}); 1527 public static readonly BitSet _ID_in_stat105 = new BitSet(new ulong[]{0x20000UL}); 1528 public static readonly BitSet _17_in_stat107 = new BitSet(new ulong[]{0x10C0UL}); 1529 public static readonly BitSet _expr_in_stat109 = new BitSet(new ulong[]{0x100UL}); 1530 public static readonly BitSet _NEWLINE_in_stat111 = new BitSet(new ulong[]{0x2UL}); 1531 public static readonly BitSet _func_in_stat143 = new BitSet(new ulong[]{0x100UL}); 1532 public static readonly BitSet _NEWLINE_in_stat145 = new BitSet(new ulong[]{0x2UL}); 1533 public static readonly BitSet _NEWLINE_in_stat178 = new BitSet(new ulong[]{0x2UL}); 1534 public static readonly BitSet _ID_in_func219 = new BitSet(new ulong[]{0x1000UL}); 1535 public static readonly BitSet _12_in_func222 = new BitSet(new ulong[]{0xC0UL}); 1536 public static readonly BitSet _formalPar_in_func224 = new BitSet(new ulong[]{0x2000UL}); 1537 public static readonly BitSet _13_in_func226 = new BitSet(new ulong[]{0x20000UL}); 1538 public static readonly BitSet _17_in_func228 = new BitSet(new ulong[]{0x10C0UL}); 1539 public static readonly BitSet _expr_in_func230 = new BitSet(new ulong[]{0x2UL}); 1540 public static readonly BitSet _set_in_formalPar267 = new BitSet(new ulong[]{0x2UL}); 1541 public static readonly BitSet _multExpr_in_expr288 = new BitSet(new ulong[]{0x10402UL}); 1542 public static readonly BitSet _16_in_expr292 = new BitSet(new ulong[]{0x10C0UL}); 1543 public static readonly BitSet _10_in_expr295 = new BitSet(new ulong[]{0x10C0UL}); 1544 public static readonly BitSet _multExpr_in_expr299 = new BitSet(new ulong[]{0x10402UL}); 1545 public static readonly BitSet _atom_in_multExpr320 = new BitSet(new ulong[]{0xC802UL}); 1546 public static readonly BitSet _set_in_multExpr323 = new BitSet(new ulong[]{0x10C0UL}); 1547 public static readonly BitSet _atom_in_multExpr332 = new BitSet(new ulong[]{0xC802UL}); 1548 public static readonly BitSet _INT_in_atom348 = new BitSet(new ulong[]{0x2UL}); 1549 public static readonly BitSet _ID_in_atom358 = new BitSet(new ulong[]{0x2UL}); 1550 public static readonly BitSet _12_in_atom368 = new BitSet(new ulong[]{0x10C0UL}); 1551 public static readonly BitSet _expr_in_atom370 = new BitSet(new ulong[]{0x2000UL}); 1552 public static readonly BitSet _13_in_atom372 = new BitSet(new ulong[]{0x2UL}); 1553 public static readonly BitSet _ID_in_atom389 = new BitSet(new ulong[]{0x1000UL}); 1554 public static readonly BitSet _12_in_atom391 = new BitSet(new ulong[]{0x10C0UL}); 1555 public static readonly BitSet _expr_in_atom393 = new BitSet(new ulong[]{0x2000UL}); 1556 public static readonly BitSet _13_in_atom395 = new BitSet(new ulong[]{0x2UL}); 1557 1558 } 1559 #endregion Follow sets 1560 } 1561