/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Parser.cs

Large files files are truncated, but you can click here to view the full file

   1using System;
   2using System.Collections;
   3using System.Collections.Generic;
   4
   5
   6
   7namespace ICSharpCode.NRefactory.VB.Parser {
   8
   9
  10
  11partial class ExpressionFinder {
  12	const int startOfExpression = 55;
  13	const int endOfStatementTerminatorAndBlock = 263;
  14	static BitArray GetExpectedSet(int state)
  15	{
  16		switch (state) {
  17			case 0:
  18			case 1:
  19				return set[0];
  20			case 2:
  21				return set[1];
  22			case 3:
  23			case 4:
  24				return set[2];
  25			case 5:
  26				return set[3];
  27			case 6:
  28			case 88:
  29			case 264:
  30			case 530:
  31				{
  32					BitArray a = new BitArray(239);
  33					return a;
  34				}
  35			case 7:
  36				return set[4];
  37			case 8:
  38				return set[5];
  39			case 9:
  40			case 10:
  41			case 20:
  42				{
  43					BitArray a = new BitArray(239);
  44					a.Set(142, true);
  45					return a;
  46				}
  47			case 11:
  48			case 193:
  49			case 199:
  50			case 205:
  51			case 244:
  52			case 248:
  53			case 295:
  54			case 399:
  55			case 405:
  56			case 474:
  57			case 520:
  58			case 527:
  59			case 535:
  60			case 565:
  61			case 601:
  62			case 650:
  63			case 664:
  64			case 743:
  65				return set[6];
  66			case 12:
  67			case 13:
  68			case 566:
  69			case 567:
  70			case 612:
  71			case 622:
  72				{
  73					BitArray a = new BitArray(239);
  74					a.Set(1, true);
  75					a.Set(21, true);
  76					a.Set(37, true);
  77					return a;
  78				}
  79			case 14:
  80			case 21:
  81			case 23:
  82			case 24:
  83			case 36:
  84			case 256:
  85			case 259:
  86			case 260:
  87			case 296:
  88			case 300:
  89			case 322:
  90			case 337:
  91			case 348:
  92			case 351:
  93			case 357:
  94			case 362:
  95			case 372:
  96			case 373:
  97			case 396:
  98			case 423:
  99			case 526:
 100			case 532:
 101			case 538:
 102			case 542:
 103			case 550:
 104			case 558:
 105			case 568:
 106			case 577:
 107			case 594:
 108			case 599:
 109			case 607:
 110			case 613:
 111			case 616:
 112			case 623:
 113			case 626:
 114			case 645:
 115			case 648:
 116			case 672:
 117			case 680:
 118			case 716:
 119				{
 120					BitArray a = new BitArray(239);
 121					a.Set(1, true);
 122					a.Set(21, true);
 123					return a;
 124				}
 125			case 15:
 126			case 16:
 127				return set[7];
 128			case 17:
 129			case 18:
 130				return set[8];
 131			case 19:
 132			case 257:
 133			case 271:
 134			case 298:
 135			case 352:
 136			case 397:
 137			case 454:
 138			case 575:
 139			case 595:
 140			case 614:
 141			case 618:
 142			case 624:
 143			case 646:
 144			case 681:
 145				{
 146					BitArray a = new BitArray(239);
 147					a.Set(113, true);
 148					return a;
 149				}
 150			case 22:
 151			case 543:
 152			case 578:
 153				return set[9];
 154			case 25:
 155				{
 156					BitArray a = new BitArray(239);
 157					a.Set(1, true);
 158					return a;
 159				}
 160			case 26:
 161			case 27:
 162				return set[10];
 163			case 28:
 164			case 720:
 165				return set[11];
 166			case 29:
 167				return set[12];
 168			case 30:
 169				return set[13];
 170			case 31:
 171			case 32:
 172			case 152:
 173			case 217:
 174			case 218:
 175			case 265:
 176			case 276:
 177			case 277:
 178			case 444:
 179			case 445:
 180			case 462:
 181			case 463:
 182			case 464:
 183			case 465:
 184			case 553:
 185			case 554:
 186			case 587:
 187			case 588:
 188			case 675:
 189			case 676:
 190			case 729:
 191			case 730:
 192				return set[14];
 193			case 33:
 194			case 34:
 195			case 521:
 196			case 522:
 197			case 528:
 198			case 529:
 199			case 555:
 200			case 556:
 201			case 669:
 202				return set[15];
 203			case 35:
 204			case 37:
 205			case 157:
 206			case 168:
 207			case 171:
 208			case 187:
 209			case 203:
 210			case 221:
 211			case 307:
 212			case 332:
 213			case 422:
 214			case 440:
 215			case 477:
 216			case 531:
 217			case 549:
 218			case 557:
 219			case 629:
 220			case 632:
 221			case 654:
 222			case 657:
 223			case 659:
 224			case 671:
 225			case 684:
 226			case 686:
 227			case 709:
 228			case 712:
 229			case 715:
 230			case 721:
 231			case 724:
 232			case 742:
 233				return set[16];
 234			case 38:
 235			case 41:
 236				return set[17];
 237			case 39:
 238				return set[18];
 239			case 40:
 240			case 97:
 241			case 101:
 242			case 163:
 243			case 388:
 244			case 481:
 245				return set[19];
 246			case 42:
 247			case 177:
 248			case 184:
 249			case 189:
 250			case 253:
 251			case 424:
 252			case 451:
 253			case 473:
 254			case 476:
 255			case 589:
 256			case 590:
 257			case 642:
 258				{
 259					BitArray a = new BitArray(239);
 260					a.Set(37, true);
 261					return a;
 262				}
 263			case 43:
 264			case 44:
 265			case 165:
 266			case 166:
 267				return set[20];
 268			case 45:
 269			case 46:
 270			case 167:
 271			case 188:
 272			case 392:
 273			case 427:
 274			case 475:
 275			case 478:
 276			case 498:
 277			case 561:
 278			case 592:
 279			case 644:
 280			case 690:
 281			case 719:
 282			case 728:
 283				{
 284					BitArray a = new BitArray(239);
 285					a.Set(38, true);
 286					return a;
 287				}
 288			case 47:
 289			case 48:
 290				return set[21];
 291			case 49:
 292			case 179:
 293			case 186:
 294			case 394:
 295				{
 296					BitArray a = new BitArray(239);
 297					a.Set(22, true);
 298					return a;
 299				}
 300			case 50:
 301			case 51:
 302			case 52:
 303			case 54:
 304			case 390:
 305			case 391:
 306			case 412:
 307			case 413:
 308			case 419:
 309			case 420:
 310			case 489:
 311			case 490:
 312			case 703:
 313			case 704:
 314				return set[22];
 315			case 53:
 316			case 169:
 317			case 170:
 318			case 172:
 319			case 181:
 320			case 414:
 321			case 421:
 322			case 429:
 323			case 438:
 324			case 442:
 325			case 485:
 326			case 488:
 327			case 492:
 328			case 494:
 329			case 495:
 330			case 505:
 331			case 512:
 332			case 519:
 333			case 705:
 334				{
 335					BitArray a = new BitArray(239);
 336					a.Set(22, true);
 337					a.Set(38, true);
 338					return a;
 339				}
 340			case 55:
 341			case 56:
 342			case 70:
 343			case 75:
 344			case 76:
 345			case 77:
 346			case 83:
 347			case 99:
 348			case 155:
 349			case 178:
 350			case 180:
 351			case 182:
 352			case 185:
 353			case 195:
 354			case 197:
 355			case 215:
 356			case 239:
 357			case 274:
 358			case 284:
 359			case 286:
 360			case 287:
 361			case 304:
 362			case 321:
 363			case 326:
 364			case 335:
 365			case 341:
 366			case 343:
 367			case 347:
 368			case 350:
 369			case 356:
 370			case 367:
 371			case 369:
 372			case 370:
 373			case 376:
 374			case 393:
 375			case 395:
 376			case 415:
 377			case 439:
 378			case 467:
 379			case 483:
 380			case 484:
 381			case 486:
 382			case 487:
 383			case 548:
 384			case 628:
 385				return set[23];
 386			case 57:
 387			case 78:
 388			case 158:
 389				return set[24];
 390			case 58:
 391				return set[25];
 392			case 59:
 393				{
 394					BitArray a = new BitArray(239);
 395					a.Set(216, true);
 396					return a;
 397				}
 398			case 60:
 399				{
 400					BitArray a = new BitArray(239);
 401					a.Set(145, true);
 402					return a;
 403				}
 404			case 61:
 405			case 156:
 406				{
 407					BitArray a = new BitArray(239);
 408					a.Set(144, true);
 409					return a;
 410				}
 411			case 62:
 412				{
 413					BitArray a = new BitArray(239);
 414					a.Set(236, true);
 415					return a;
 416				}
 417			case 63:
 418				{
 419					BitArray a = new BitArray(239);
 420					a.Set(177, true);
 421					return a;
 422				}
 423			case 64:
 424				{
 425					BitArray a = new BitArray(239);
 426					a.Set(175, true);
 427					return a;
 428				}
 429			case 65:
 430				{
 431					BitArray a = new BitArray(239);
 432					a.Set(61, true);
 433					return a;
 434				}
 435			case 66:
 436				{
 437					BitArray a = new BitArray(239);
 438					a.Set(60, true);
 439					return a;
 440				}
 441			case 67:
 442				{
 443					BitArray a = new BitArray(239);
 444					a.Set(150, true);
 445					return a;
 446				}
 447			case 68:
 448				{
 449					BitArray a = new BitArray(239);
 450					a.Set(42, true);
 451					return a;
 452				}
 453			case 69:
 454				{
 455					BitArray a = new BitArray(239);
 456					a.Set(43, true);
 457					return a;
 458				}
 459			case 71:
 460			case 443:
 461				{
 462					BitArray a = new BitArray(239);
 463					a.Set(40, true);
 464					return a;
 465				}
 466			case 72:
 467				{
 468					BitArray a = new BitArray(239);
 469					a.Set(41, true);
 470					return a;
 471				}
 472			case 73:
 473			case 98:
 474			case 222:
 475			case 223:
 476			case 282:
 477			case 283:
 478			case 334:
 479			case 744:
 480				{
 481					BitArray a = new BitArray(239);
 482					a.Set(20, true);
 483					return a;
 484				}
 485			case 74:
 486				{
 487					BitArray a = new BitArray(239);
 488					a.Set(154, true);
 489					return a;
 490				}
 491			case 79:
 492			case 91:
 493			case 93:
 494			case 148:
 495				{
 496					BitArray a = new BitArray(239);
 497					a.Set(35, true);
 498					return a;
 499				}
 500			case 80:
 501			case 81:
 502				return set[26];
 503			case 82:
 504				{
 505					BitArray a = new BitArray(239);
 506					a.Set(36, true);
 507					return a;
 508				}
 509			case 84:
 510			case 100:
 511			case 515:
 512				{
 513					BitArray a = new BitArray(239);
 514					a.Set(22, true);
 515					a.Set(36, true);
 516					return a;
 517				}
 518			case 85:
 519			case 121:
 520				{
 521					BitArray a = new BitArray(239);
 522					a.Set(162, true);
 523					return a;
 524				}
 525			case 86:
 526			case 87:
 527				return set[27];
 528			case 89:
 529			case 92:
 530			case 149:
 531			case 150:
 532			case 153:
 533				return set[28];
 534			case 90:
 535			case 102:
 536			case 147:
 537				{
 538					BitArray a = new BitArray(239);
 539					a.Set(233, true);
 540					return a;
 541				}
 542			case 94:
 543				{
 544					BitArray a = new BitArray(239);
 545					a.Set(26, true);
 546					a.Set(36, true);
 547					a.Set(147, true);
 548					return a;
 549				}
 550			case 95:
 551				{
 552					BitArray a = new BitArray(239);
 553					a.Set(26, true);
 554					a.Set(147, true);
 555					return a;
 556				}
 557			case 96:
 558			case 685:
 559				{
 560					BitArray a = new BitArray(239);
 561					a.Set(26, true);
 562					return a;
 563				}
 564			case 103:
 565			case 353:
 566				{
 567					BitArray a = new BitArray(239);
 568					a.Set(231, true);
 569					return a;
 570				}
 571			case 104:
 572				{
 573					BitArray a = new BitArray(239);
 574					a.Set(230, true);
 575					return a;
 576				}
 577			case 105:
 578				{
 579					BitArray a = new BitArray(239);
 580					a.Set(224, true);
 581					return a;
 582				}
 583			case 106:
 584				{
 585					BitArray a = new BitArray(239);
 586					a.Set(223, true);
 587					return a;
 588				}
 589			case 107:
 590			case 299:
 591				{
 592					BitArray a = new BitArray(239);
 593					a.Set(218, true);
 594					return a;
 595				}
 596			case 108:
 597				{
 598					BitArray a = new BitArray(239);
 599					a.Set(213, true);
 600					return a;
 601				}
 602			case 109:
 603				{
 604					BitArray a = new BitArray(239);
 605					a.Set(212, true);
 606					return a;
 607				}
 608			case 110:
 609				{
 610					BitArray a = new BitArray(239);
 611					a.Set(211, true);
 612					return a;
 613				}
 614			case 111:
 615			case 455:
 616				{
 617					BitArray a = new BitArray(239);
 618					a.Set(210, true);
 619					return a;
 620				}
 621			case 112:
 622				{
 623					BitArray a = new BitArray(239);
 624					a.Set(209, true);
 625					return a;
 626				}
 627			case 113:
 628				{
 629					BitArray a = new BitArray(239);
 630					a.Set(206, true);
 631					return a;
 632				}
 633			case 114:
 634				{
 635					BitArray a = new BitArray(239);
 636					a.Set(203, true);
 637					return a;
 638				}
 639			case 115:
 640			case 359:
 641				{
 642					BitArray a = new BitArray(239);
 643					a.Set(197, true);
 644					return a;
 645				}
 646			case 116:
 647			case 600:
 648			case 619:
 649				{
 650					BitArray a = new BitArray(239);
 651					a.Set(186, true);
 652					return a;
 653				}
 654			case 117:
 655				{
 656					BitArray a = new BitArray(239);
 657					a.Set(184, true);
 658					return a;
 659				}
 660			case 118:
 661				{
 662					BitArray a = new BitArray(239);
 663					a.Set(176, true);
 664					return a;
 665				}
 666			case 119:
 667				{
 668					BitArray a = new BitArray(239);
 669					a.Set(170, true);
 670					return a;
 671				}
 672			case 120:
 673			case 316:
 674			case 323:
 675			case 338:
 676				{
 677					BitArray a = new BitArray(239);
 678					a.Set(163, true);
 679					return a;
 680				}
 681			case 122:
 682				{
 683					BitArray a = new BitArray(239);
 684					a.Set(147, true);
 685					return a;
 686				}
 687			case 123:
 688			case 226:
 689			case 231:
 690			case 233:
 691				{
 692					BitArray a = new BitArray(239);
 693					a.Set(146, true);
 694					return a;
 695				}
 696			case 124:
 697			case 228:
 698			case 232:
 699				{
 700					BitArray a = new BitArray(239);
 701					a.Set(143, true);
 702					return a;
 703				}
 704			case 125:
 705				{
 706					BitArray a = new BitArray(239);
 707					a.Set(139, true);
 708					return a;
 709				}
 710			case 126:
 711				{
 712					BitArray a = new BitArray(239);
 713					a.Set(133, true);
 714					return a;
 715				}
 716			case 127:
 717			case 258:
 718				{
 719					BitArray a = new BitArray(239);
 720					a.Set(127, true);
 721					return a;
 722				}
 723			case 128:
 724			case 151:
 725			case 251:
 726				{
 727					BitArray a = new BitArray(239);
 728					a.Set(126, true);
 729					return a;
 730				}
 731			case 129:
 732				{
 733					BitArray a = new BitArray(239);
 734					a.Set(124, true);
 735					return a;
 736				}
 737			case 130:
 738				{
 739					BitArray a = new BitArray(239);
 740					a.Set(121, true);
 741					return a;
 742				}
 743			case 131:
 744			case 196:
 745				{
 746					BitArray a = new BitArray(239);
 747					a.Set(116, true);
 748					return a;
 749				}
 750			case 132:
 751				{
 752					BitArray a = new BitArray(239);
 753					a.Set(108, true);
 754					return a;
 755				}
 756			case 133:
 757				{
 758					BitArray a = new BitArray(239);
 759					a.Set(107, true);
 760					return a;
 761				}
 762			case 134:
 763				{
 764					BitArray a = new BitArray(239);
 765					a.Set(104, true);
 766					return a;
 767				}
 768			case 135:
 769			case 637:
 770				{
 771					BitArray a = new BitArray(239);
 772					a.Set(98, true);
 773					return a;
 774				}
 775			case 136:
 776				{
 777					BitArray a = new BitArray(239);
 778					a.Set(87, true);
 779					return a;
 780				}
 781			case 137:
 782				{
 783					BitArray a = new BitArray(239);
 784					a.Set(84, true);
 785					return a;
 786				}
 787			case 138:
 788			case 208:
 789			case 238:
 790				{
 791					BitArray a = new BitArray(239);
 792					a.Set(70, true);
 793					return a;
 794				}
 795			case 139:
 796				{
 797					BitArray a = new BitArray(239);
 798					a.Set(67, true);
 799					return a;
 800				}
 801			case 140:
 802				{
 803					BitArray a = new BitArray(239);
 804					a.Set(66, true);
 805					return a;
 806				}
 807			case 141:
 808				{
 809					BitArray a = new BitArray(239);
 810					a.Set(65, true);
 811					return a;
 812				}
 813			case 142:
 814				{
 815					BitArray a = new BitArray(239);
 816					a.Set(64, true);
 817					return a;
 818				}
 819			case 143:
 820				{
 821					BitArray a = new BitArray(239);
 822					a.Set(62, true);
 823					return a;
 824				}
 825			case 144:
 826			case 250:
 827				{
 828					BitArray a = new BitArray(239);
 829					a.Set(58, true);
 830					return a;
 831				}
 832			case 145:
 833				{
 834					BitArray a = new BitArray(239);
 835					a.Set(2, true);
 836					return a;
 837				}
 838			case 146:
 839				return set[29];
 840			case 154:
 841				return set[30];
 842			case 159:
 843				return set[31];
 844			case 160:
 845				return set[32];
 846			case 161:
 847			case 162:
 848			case 479:
 849			case 480:
 850				return set[33];
 851			case 164:
 852				return set[34];
 853			case 173:
 854			case 174:
 855			case 319:
 856			case 328:
 857				return set[35];
 858			case 175:
 859			case 457:
 860				return set[36];
 861			case 176:
 862			case 375:
 863				{
 864					BitArray a = new BitArray(239);
 865					a.Set(135, true);
 866					return a;
 867				}
 868			case 183:
 869				return set[37];
 870			case 190:
 871				{
 872					BitArray a = new BitArray(239);
 873					a.Set(58, true);
 874					a.Set(126, true);
 875					return a;
 876				}
 877			case 191:
 878			case 192:
 879				return set[38];
 880			case 194:
 881				{
 882					BitArray a = new BitArray(239);
 883					a.Set(171, true);
 884					return a;
 885				}
 886			case 198:
 887			case 212:
 888			case 230:
 889			case 235:
 890			case 241:
 891			case 243:
 892			case 247:
 893			case 249:
 894				return set[39];
 895			case 200:
 896			case 201:
 897				{
 898					BitArray a = new BitArray(239);
 899					a.Set(63, true);
 900					a.Set(138, true);
 901					return a;
 902				}
 903			case 202:
 904			case 204:
 905			case 320:
 906				{
 907					BitArray a = new BitArray(239);
 908					a.Set(138, true);
 909					return a;
 910				}
 911			case 206:
 912			case 207:
 913			case 209:
 914			case 211:
 915			case 213:
 916			case 214:
 917			case 224:
 918			case 229:
 919			case 234:
 920			case 242:
 921			case 246:
 922			case 269:
 923			case 273:
 924				return set[40];
 925			case 210:
 926				{
 927					BitArray a = new BitArray(239);
 928					a.Set(22, true);
 929					a.Set(143, true);
 930					return a;
 931				}
 932			case 216:
 933				return set[41];
 934			case 219:
 935			case 278:
 936				return set[42];
 937			case 220:
 938			case 279:
 939				return set[43];
 940			case 225:
 941				{
 942					BitArray a = new BitArray(239);
 943					a.Set(22, true);
 944					a.Set(70, true);
 945					return a;
 946				}
 947			case 227:
 948				{
 949					BitArray a = new BitArray(239);
 950					a.Set(133, true);
 951					a.Set(143, true);
 952					a.Set(146, true);
 953					return a;
 954				}
 955			case 236:
 956			case 237:
 957				return set[44];
 958			case 240:
 959				{
 960					BitArray a = new BitArray(239);
 961					a.Set(64, true);
 962					a.Set(104, true);
 963					return a;
 964				}
 965			case 245:
 966				return set[45];
 967			case 252:
 968			case 552:
 969			case 663:
 970			case 674:
 971			case 682:
 972				{
 973					BitArray a = new BitArray(239);
 974					a.Set(127, true);
 975					a.Set(210, true);
 976					return a;
 977				}
 978			case 254:
 979			case 255:
 980				return set[46];
 981			case 261:
 982			case 262:
 983				return set[47];
 984			case 263:
 985				return set[48];
 986			case 266:
 987				return set[49];
 988			case 267:
 989			case 268:
 990			case 381:
 991				return set[50];
 992			case 270:
 993			case 275:
 994			case 365:
 995			case 655:
 996			case 656:
 997			case 658:
 998			case 693:
 999			case 710:
1000			case 711:
1001			case 713:
1002			case 722:
1003			case 723:
1004			case 725:
1005			case 737:
1006				{
1007					BitArray a = new BitArray(239);
1008					a.Set(1, true);
1009					a.Set(21, true);
1010					a.Set(22, true);
1011					return a;
1012				}
1013			case 272:
1014				{
1015					BitArray a = new BitArray(239);
1016					a.Set(226, true);
1017					return a;
1018				}
1019			case 280:
1020			case 281:
1021				return set[51];
1022			case 285:
1023			case 327:
1024			case 342:
1025			case 404:
1026				return set[52];
1027			case 288:
1028			case 289:
1029			case 309:
1030			case 310:
1031			case 324:
1032			case 325:
1033			case 339:
1034			case 340:
1035				return set[53];
1036			case 290:
1037			case 382:
1038			case 385:
1039				{
1040					BitArray a = new BitArray(239);
1041					a.Set(1, true);
1042					a.Set(21, true);
1043					a.Set(111, true);
1044					return a;
1045				}
1046			case 291:
1047				{
1048					BitArray a = new BitArray(239);
1049					a.Set(108, true);
1050					a.Set(124, true);
1051					a.Set(231, true);
1052					return a;
1053				}
1054			case 292:
1055				return set[54];
1056			case 293:
1057			case 312:
1058				return set[55];
1059			case 294:
1060				{
1061					BitArray a = new BitArray(239);
1062					a.Set(5, true);
1063					return a;
1064				}
1065			case 297:
1066				{
1067					BitArray a = new BitArray(239);
1068					a.Set(75, true);
1069					a.Set(113, true);
1070					a.Set(123, true);
1071					return a;
1072				}
1073			case 301:
1074			case 302:
1075				return set[56];
1076			case 303:
1077			case 308:
1078				{
1079					BitArray a = new BitArray(239);
1080					a.Set(1, true);
1081					a.Set(21, true);
1082					a.Set(229, true);
1083					return a;
1084				}
1085			case 305:
1086			case 306:
1087				return set[57];
1088			case 311:
1089				return set[58];
1090			case 313:
1091				{
1092					BitArray a = new BitArray(239);
1093					a.Set(118, true);
1094					return a;
1095				}
1096			case 314:
1097			case 315:
1098				return set[59];
1099			case 317:
1100			case 318:
1101				return set[60];
1102			case 329:
1103			case 330:
1104				return set[61];
1105			case 331:
1106				return set[62];
1107			case 333:
1108				{
1109					BitArray a = new BitArray(239);
1110					a.Set(20, true);
1111					a.Set(138, true);
1112					return a;
1113				}
1114			case 336:
1115				{
1116					BitArray a = new BitArray(239);
1117					a.Set(1, true);
1118					a.Set(21, true);
1119					a.Set(205, true);
1120					return a;
1121				}
1122			case 344:
1123				return set[63];
1124			case 345:
1125			case 349:
1126				{
1127					BitArray a = new BitArray(239);
1128					a.Set(152, true);
1129					return a;
1130				}
1131			case 346:
1132				return set[64];
1133			case 354:
1134			case 355:
1135				return set[65];
1136			case 358:
1137				{
1138					BitArray a = new BitArray(239);
1139					a.Set(74, true);
1140					a.Set(113, true);
1141					return a;
1142				}
1143			case 360:
1144			case 361:
1145				return set[66];
1146			case 363:
1147			case 364:
1148				return set[67];
1149			case 366:
1150			case 368:
1151				return set[68];
1152			case 371:
1153			case 377:
1154				{
1155					BitArray a = new BitArray(239);
1156					a.Set(1, true);
1157					a.Set(21, true);
1158					a.Set(214, true);
1159					return a;
1160				}
1161			case 374:
1162				{
1163					BitArray a = new BitArray(239);
1164					a.Set(111, true);
1165					a.Set(112, true);
1166					a.Set(113, true);
1167					return a;
1168				}
1169			case 378:
1170				{
1171					BitArray a = new BitArray(239);
1172					a.Set(1, true);
1173					a.Set(21, true);
1174					a.Set(135, true);
1175					return a;
1176				}
1177			case 379:
1178			case 380:
1179			case 452:
1180			case 453:
1181				return set[69];
1182			case 383:
1183			case 384:
1184			case 386:
1185			case 387:
1186				return set[70];
1187			case 389:
1188				return set[71];
1189			case 398:
1190				{
1191					BitArray a = new BitArray(239);
1192					a.Set(211, true);
1193					a.Set(233, true);
1194					return a;
1195				}
1196			case 400:
1197			case 401:
1198			case 406:
1199			case 407:
1200				return set[72];
1201			case 402:
1202			case 408:
1203				return set[73];
1204			case 403:
1205			case 411:
1206			case 418:
1207				return set[74];
1208			case 409:
1209			case 410:
1210			case 416:
1211			case 417:
1212			case 700:
1213			case 701:
1214				return set[75];
1215			case 425:
1216			case 426:
1217				return set[76];
1218			case 428:
1219			case 430:
1220			case 431:
1221			case 591:
1222			case 643:
1223				return set[77];
1224			case 432:
1225			case 433:
1226				return set[78];
1227			case 434:
1228			case 435:
1229				return set[79];
1230			case 436:
1231				return set[80];
1232			case 437:
1233			case 441:
1234				{
1235					BitArray a = new BitArray(239);
1236					a.Set(20, true);
1237					a.Set(22, true);
1238					a.Set(38, true);
1239					return a;
1240				}
1241			case 446:
1242			case 450:
1243				return set[81];
1244			case 447:
1245			case 448:
1246				return set[82];
1247			case 449:
1248				{
1249					BitArray a = new BitArray(239);
1250					a.Set(21, true);
1251					return a;
1252				}
1253			case 456:
1254				return set[83];
1255			case 458:
1256			case 471:
1257				return set[84];
1258			case 459:
1259			case 472:
1260				return set[85];
1261			case 460:
1262			case 461:
1263			case 736:
1264				{
1265					BitArray a = new BitArray(239);
1266					a.Set(10, true);
1267					return a;
1268				}
1269			case 466:
1270				{
1271					BitArray a = new BitArray(239);
1272					a.Set(12, true);
1273					return a;
1274				}
1275			case 468:
1276				{
1277					BitArray a = new BitArray(239);
1278					a.Set(13, true);
1279					return a;
1280				}
1281			case 469:
1282				return set[86];
1283			case 470:
1284				return set[87];
1285			case 482:
1286				return set[88];
1287			case 491:
1288			case 493:
1289				return set[89];
1290			case 496:
1291			case 497:
1292			case 559:
1293			case 560:
1294			case 688:
1295			case 689:
1296				return set[90];
1297			case 499:
1298			case 500:
1299			case 501:
1300			case 506:
1301			case 507:
1302			case 562:
1303			case 691:
1304			case 718:
1305			case 727:
1306				return set[91];
1307			case 502:
1308			case 508:
1309			case 517:
1310				return set[92];
1311			case 503:
1312			case 504:
1313			case 509:
1314			case 510:
1315				{
1316					BitArray a = new BitArray(239);
1317					a.Set(22, true);
1318					a.Set(38, true);
1319					a.Set(63, true);
1320					return a;
1321				}
1322			case 511:
1323			case 513:
1324			case 518:
1325				return set[93];
1326			case 514:
1327			case 516:
1328				return set[94];
1329			case 523:
1330			case 536:
1331			case 537:
1332			case 593:
1333			case 670:
1334				{
1335					BitArray a = new BitArray(239);
1336					a.Set(1, true);
1337					a.Set(21, true);
1338					a.Set(63, true);
1339					return a;
1340				}
1341			case 524:
1342			case 525:
1343			case 597:
1344			case 598:
1345				return set[95];
1346			case 533:
1347			case 534:
1348			case 541:
1349				{
1350					BitArray a = new BitArray(239);
1351					a.Set(115, true);
1352					return a;
1353				}
1354			case 539:
1355			case 540:
1356				return set[96];
1357			case 544:
1358			case 545:
1359				return set[97];
1360			case 546:
1361			case 547:
1362			case 606:
1363				{
1364					BitArray a = new BitArray(239);
1365					a.Set(1, true);
1366					a.Set(20, true);
1367					a.Set(21, true);
1368					return a;
1369				}
1370			case 551:
1371				{
1372					BitArray a = new BitArray(239);
1373					a.Set(103, true);
1374					return a;
1375				}
1376			case 563:
1377			case 564:
1378			case 576:
1379				{
1380					BitArray a = new BitArray(239);
1381					a.Set(84, true);
1382					a.Set(155, true);
1383					a.Set(209, true);
1384					return a;
1385				}
1386			case 569:
1387			case 570:
1388				return set[98];
1389			case 571:
1390			case 572:
1391				return set[99];
1392			case 573:
1393			case 574:
1394			case 585:
1395				return set[100];
1396			case 579:
1397			case 580:
1398				return set[101];
1399			case 581:
1400			case 582:
1401			case 707:
1402				return set[102];
1403			case 583:
1404				return set[103];
1405			case 584:
1406				return set[104];
1407			case 586:
1408			case 596:
1409				{
1410					BitArray a = new BitArray(239);
1411					a.Set(172, true);
1412					return a;
1413				}
1414			case 602:
1415			case 603:
1416				return set[105];
1417			case 604:
1418				return set[106];
1419			case 605:
1420			case 636:
1421				return set[107];
1422			case 608:
1423			case 609:
1424			case 610:
1425			case 627:
1426				return set[108];
1427			case 611:
1428			case 615:
1429			case 625:
1430				{
1431					BitArray a = new BitArray(239);
1432					a.Set(128, true);
1433					a.Set(198, true);
1434					return a;
1435				}
1436			case 617:
1437				return set[109];
1438			case 620:
1439				return set[110];
1440			case 621:
1441				return set[111];
1442			case 630:
1443			case 631:
1444			case 633:
1445			case 699:
1446			case 702:
1447				return set[112];
1448			case 634:
1449			case 635:
1450				return set[113];
1451			case 638:
1452			case 640:
1453			case 649:
1454				{
1455					BitArray a = new BitArray(239);
1456					a.Set(119, true);
1457					return a;
1458				}
1459			case 639:
1460				return set[114];
1461			case 641:
1462				return set[115];
1463			case 647:
1464				{
1465					BitArray a = new BitArray(239);
1466					a.Set(56, true);
1467					a.Set(189, true);
1468					a.Set(193, true);
1469					return a;
1470				}
1471			case 651:
1472			case 652:
1473				return set[116];
1474			case 653:
1475			case 660:
1476				{
1477					BitArray a = new BitArray(239);
1478					a.Set(1, true);
1479					a.Set(21, true);
1480					a.Set(136, true);
1481					return a;
1482				}
1483			case 661:
1484				{
1485					BitArray a = new BitArray(239);
1486					a.Set(101, true);
1487					return a;
1488				}
1489			case 662:
1490				return set[117];
1491			case 665:
1492			case 666:
1493				{
1494					BitArray a = new BitArray(239);
1495					a.Set(149, true);
1496					return a;
1497				}
1498			case 667:
1499			case 673:
1500			case 745:
1501				{
1502					BitArray a = new BitArray(239);
1503					a.Set(3, true);
1504					return a;
1505				}
1506			case 668:
1507				return set[118];
1508			case 677:
1509			case 678:
1510				return set[119];
1511			case 679:
1512			case 687:
1513				return set[120];
1514			case 683:
1515				return set[121];
1516			case 692:
1517			case 694:
1518				return set[122];
1519			case 695:
1520			case 706:
1521				return set[123];
1522			case 696:
1523			case 697:
1524				return set[124];
1525			case 698:
1526				return set[125];
1527			case 708:
1528				{
1529					BitArray a = new BitArray(239);
1530					a.Set(136, true);
1531					return a;
1532				}
1533			case 714:
1534				{
1535					BitArray a = new BitArray(239);
1536					a.Set(140, true);
1537					return a;
1538				}
1539			case 717:
1540			case 726:
1541				{
1542					BitArray a = new BitArray(239);
1543					a.Set(169, true);
1544					return a;
1545				}
1546			case 731:
1547				return set[126];
1548			case 732:
1549				{
1550					BitArray a = new BitArray(239);
1551					a.Set(160, true);
1552					return a;
1553				}
1554			case 733:
1555				{
1556					BitArray a = new BitArray(239);
1557					a.Set(137, true);
1558					return a;
1559				}
1560			case 734:
1561			case 735:
1562			case 738:
1563			case 739:
1564				return set[127];
1565			case 740:
1566			case 747:
1567				return set[128];
1568			case 741:
1569				return set[129];
1570			case 746:
1571				{
1572					BitArray a = new BitArray(239);
1573					a.Set(11, true);
1574					return a;
1575				}
1576			case 748:
1577				{
1578					BitArray a = new BitArray(239);
1579					a.Set(173, true);
1580					return a;
1581				}
1582			case 749:
1583				return set[130];
1584			case 750:
1585				{
1586					BitArray a = new BitArray(239);
1587					a.Set(67, true);
1588					a.Set(213, true);
1589					return a;
1590				}
1591			case 751:
1592				return set[131];
1593			default: throw new InvalidOperationException();
1594		}
1595	}
1596
1597	const bool T = true;
1598	const bool x = false;
1599
1600	int currentState = 0;
1601
1602	readonly Stack<int> stateStack = new Stack<int>();
1603	bool wasQualifierTokenAtStart = false;
1604	bool nextTokenIsPotentialStartOfExpression = false;
1605	bool readXmlIdentifier = false;
1606	bool identifierExpected = false;
1607	bool nextTokenIsStartOfImportsOrAccessExpression = false;
1608	bool isMissingModifier = false;
1609	bool isAlreadyInExpr = false;
1610	bool wasNormalAttribute = false;
1611	int activeArgument = 0;
1612	List<Token> errors = new List<Token>();
1613	
1614	public ExpressionFinder()
1615	{
1616		stateStack.Push(-1); // required so that we don't crash when leaving the root production
1617	}
1618
1619	void Expect(int expectedKind, Token la)
1620	{
1621		if (la.kind != expectedKind) {
1622			Error(la);
1623			output.AppendLine("expected: " + expectedKind);
1624			//Console.WriteLine("expected: " + expectedKind);
1625		}
1626	}
1627	
1628	void Error(Token la) 
1629	{
1630		output.AppendLine("not expected: " + la);
1631		//Console.WriteLine("not expected: " + la);
1632		errors.Add(la);
1633	}
1634	
1635	Token t;
1636	
1637	public void InformToken(Token la) 
1638	{
1639		switchlbl: switch (currentState) {
1640			case 0: {
1641				PushContext(Context.Global, la, t);
1642				goto case 1;
1643			}
1644			case 1: {
1645				if (la == null) { currentState = 1; break; }
1646				if (la.kind == 173) {
1647					stateStack.Push(1);
1648					goto case 748;
1649				} else {
1650					goto case 2;
1651				}
1652			}
1653			case 2: {
1654				if (la == null) { currentState = 2; break; }
1655				if (la.kind == 137) {
1656					stateStack.Push(2);
1657					goto case 733;
1658				} else {
1659					goto case 3;
1660				}
1661			}
1662			case 3: {
1663				if (la == null) { currentState = 3; break; }
1664				if (la.kind == 40) {
1665					stateStack.Push(3);
1666					goto case 443;
1667				} else {
1668					goto case 4;
1669				}
1670			}
1671			case 4: {
1672				if (la == null) { currentState = 4; break; }
1673				if (set[3].Get(la.kind)) {
1674					stateStack.Push(4);
1675					goto case 5;
1676				} else {
1677					PopContext();
1678					currentState = stateStack.Pop();
1679					goto switchlbl;
1680				}
1681			}
1682			case 5: {
1683				if (la == null) { currentState = 5; break; }
1684				if (la.kind == 160) {
1685					currentState = 729;
1686					break;
1687				} else {
1688					if (set[4].Get(la.kind)) {
1689						goto case 7;
1690					} else {
1691						goto case 6;
1692					}
1693				}
1694			}
1695			case 6: {
1696				Error(la);
1697				currentState = stateStack.Pop();
1698				goto switchlbl;
1699			}
1700			case 7: {
1701				if (la == null) { currentState = 7; break; }
1702				if (la.kind == 40) {
1703					stateStack.Push(7);
1704					goto case 443;
1705				} else {
1706					goto case 8;
1707				}
1708			}
1709			case 8: {
1710				if (la == null) { currentState = 8; break; }
1711				if (set[132].Get(la.kind)) {
1712					currentState = 8;
1713					break;
1714				} else {
1715					if (la.kind == 84 || la.kind == 155 || la.kind == 209) {
1716						goto case 563;
1717					} else {
1718						if (la.kind == 103) {
1719							currentState = 552;
1720							break;
1721						} else {
1722							if (la.kind == 115) {
1723								goto case 533;
1724							} else {
1725								if (la.kind == 142) {
1726									goto case 9;
1727								} else {
1728									goto case 6;
1729								}
1730							}
1731						}
1732					}
1733				}
1734			}
1735			case 9: {
1736				PushContext(Context.TypeDeclaration, la, t);
1737				goto case 10;
1738			}
1739			case 10: {
1740				if (la == null) { currentState = 10; break; }
1741				Expect(142, la); // "Interface"
1742				currentState = 11;
1743				break;
1744			}
1745			case 11: {
1746				PushContext(Context.Identifier, la, t);
1747				SetIdentifierExpected(la);
1748				stateStack.Push(12);
1749				goto case 205;
1750			}
1751			case 12: {
1752				PopContext();
1753				goto case 13;
1754			}
1755			case 13: {
1756				if (la == null) { currentState = 13; break; }
1757				if (la.kind == 37) {
1758					currentState = 726;
1759					break;
1760				} else {
1761					goto case 14;
1762				}
1763			}
1764			case 14: {
1765				stateStack.Push(15);
1766				goto case 23;
1767			}
1768			case 15: {
1769				isMissingModifier = true;
1770				goto case 16;
1771			}
1772			case 16: {
1773				if (la == null) { currentState = 16; break; }
1774				if (la.kind == 140) {
1775					currentState = 721;
1776					break;
1777				} else {
1778					goto case 17;
1779				}
1780			}
1781			case 17: {
1782				isMissingModifier = true;
1783				goto case 18;
1784			}
1785			case 18: {
1786				if (la == null) { currentState = 18; break; }
1787				if (set[10].Get(la.kind)) {
1788					goto case 26;
1789				} else {
1790					isMissingModifier = false;
1791					goto case 19;
1792				}
1793			}
1794			case 19: {
1795				if (la == null) { currentState = 19; break; }
1796				Expect(113, la); // "End"
1797				currentState = 20;
1798				break;
1799			}
1800			case 20: {
1801				if (la == null) { currentState = 20; break; }
1802				Expect(142, la); // "Interface"
1803				currentState = 21;
1804				break;
1805			}
1806			case 21: {
1807				stateStack.Push(22);
1808				goto case 23;
1809			}
1810			case 22: {
1811				PopContext();
1812				currentState = stateStack.Pop();
1813				goto switchlbl;
1814			}
1815			case 23: {
1816				if (la != null) CurrentBlock.lastExpressionStart = la.Location;
1817				goto case 24;
1818			}
1819			case 24: {
1820				if (la == null) { currentState = 24; break; }
1821				if (la.kind == 1) {
1822					goto case 25;
1823				} else {
1824					if (la.kind == 21) {
1825						currentState = stateStack.Pop();
1826						break;
1827					} else {
1828						goto case 6;
1829					}
1830				}
1831			}
1832			case 25: {
1833				if (la == null) { currentState = 25; break; }
1834				currentState = stateStack.Pop();
1835				break;
1836			}
1837			case 26: {
1838				isMissingModifier = true;
1839				goto case 27;
1840			}
1841			case 27: {
1842				if (la == null) { currentState = 27; break; }
1843				if (la.kind == 40) {
1844					stateStack.Push(26);
1845					goto case 443;
1846				} else {
1847					isMissingModifier = true;
1848					goto case 28;
1849				}
1850			}
1851			case 28: {
1852				if (la == null) { currentState = 28; break; }
1853				if (set[133].Get(la.kind)) {
1854					currentState = 720;
1855					break;
1856				} else {
1857					isMissingModifier = false;
1858					goto case 29;
1859				}
1860			}
1861			case 29: {
1862				if (la == null) { currentState = 29; break; }
1863				if (la.kind == 84 || la.kind == 155 || la.kind == 209) {
1864					stateStack.Push(17);
1865					goto case 563;
1866				} else {
1867					if (la.kind == 103) {
1868						stateStack.Push(17);
1869						goto case 551;
1870					} else {
1871						if (la.kind == 115) {
1872							stateStack.Push(17);
1873							goto case 533;
1874						} else {
1875							if (la.kind == 142) {
1876								stateStack.Push(17);
1877								goto case 9;
1878							} else {
1879								if (set[13].Get(la.kind)) {
1880									stateStack.Push(17);
1881									goto case 30;
1882								} else {
1883									Error(la);
1884									goto case 17;
1885								}
1886							}
1887						}
1888					}
1889				}
1890			}
1891			case 30: {
1892				if (la == null) { currentState = 30; break; }
1893				if (la.kind == 119) {
1894					currentState = 527;
1895					break;
1896				} else {
1897					if (la.kind == 186) {
1898						currentState = 520;
1899						break;
1900					} else {
1901						if (la.kind == 127 || la.kind == 210) {
1902							currentState = 31;
1903							break;
1904						} else {
1905							goto case 6;
1906						}
1907					}
1908				}
1909			}
1910			case 31: {
1911				PushContext(Context.Identifier, la, t);
1912				SetIdentifierExpected(la);
1913				goto case 32;
1914			}
1915			case 32: {
1916				if (la == null) { currentState = 32; break; }
1917				currentState = 33;
1918				break;
1919			}
1920			case 33: {
1921				PopContext();
1922				goto case 34;
1923			}
1924			case 34: {
1925				if (la == null) { currentState = 34; break; }
1926				if (la.kind == 37) {
1927					currentState = 496;
1928					break;
1929				} else {
1930					if (la.kind == 63) {
1931						currentState = 35;
1932						break;
1933					} else {
1934						goto case 23;
1935					}
1936				}
1937			}
1938			case 35: {
1939				PushContext(Context.Type, la, t);
1940				stateStack.Push(36);
1941				goto case 37;
1942			}
1943			case 36: {
1944				PopContext();
1945				goto case 23;
1946			}
1947			case 37: {
1948				if (la == null) { currentState = 37; break; }
1949				if (la.kind == 130) {
1950					currentState = 38;
1951					break;
1952				} else {
1953					if (set[6].Get(la.kind)) {
1954						currentState = 38;
1955						break;
1956					} else {
1957						if (set[134].Get(la.kind)) {
1958							currentState = 38;
1959							break;
1960						} else {
1961							if (la.kind == 33) {
1962								currentState = 38;
1963								break;
1964							} else {
1965								Error(la);
1966								goto case 38;
1967							}
1968						}
1969					}
1970				}
1971			}
1972			case 38: {
1973				if (la == null) { currentState = 38; break; }
1974				if (la.kind == 37) {
1975					stateStack.Push(38);
1976					goto case 42;
1977				} else {
1978					goto case 39;
1979				}
1980			}
1981			case 39: {
1982				if (la == null) { currentState = 39; break; }
1983				if (la.kind == 26) {
1984					currentState = 40;
1985					break;
1986				} else {
1987					currentState = stateStack.Pop();
1988					goto switchlbl;
1989				}
1990			}
1991			case 40: {
1992				stateStack.Push(41);
1993				goto case 101;
1994			}
1995			case 41: {
1996				if (la == null) { currentState = 41; break; }
1997				if (la.kind == 37) {
1998					stateStack.Push(41);
1999					goto case 42;
2000				} else {
2001					goto case 39;
2002				}
2003			}
2004			case 42: {
2005				if (la == null) { currentState = 42; break; }
2006				Expect(37, la); // "("
2007				currentState = 43;
2008				break;
2009			}
2010			case 43: {
2011				PushContext(Context.Expression, la, t);
2012				nextTokenIsPotentialStartOfExpression = true;
2013				goto case 44;
2014			}
2015			case 44: {
2016				if (la == null) { currentState = 44; break; }
2017				if (la.kind == 169) {
2018					currentState = 491;
2019					break;
2020				} else {
2021					if (set[22].Get(la.kind)) {
2022						if (set[21].Get(la.kind)) {
2023							stateStack.Push(45);
2024							goto case 47;
2025						} else {
2026							goto case 45;
2027						}
2028					} else {
2029						Error(la);
2030						goto case 45;
2031					}
2032				}
2033			}
2034			case 45: {
2035				PopContext();
2036				goto case 46;
2037			}
2038			case 46: {
2039				if (la == null) { currentState = 46; break; }
2040				Expect(38, la); // ")"
2041				currentState = stateStack.Pop();
2042				break;
2043			}
2044			case 47: {
2045				nextTokenIsPotentialStartOfExpression = true;
2046				goto case 48;
2047			}
2048			case 48: {
2049				if (la == null) { currentState = 48; break; }
2050				if (set[23].Get(la.kind)) {
2051					activeArgument = 0;
2052					goto case 487;
2053				} else {
2054					if (la.kind == 22) {
2055						activeArgument = 0;
2056						goto case 49;
2057					} else {
2058						goto case 6;
2059					}
2060				}
2061			}
2062			case 49: {
2063				if (la == null) { currentState = 49; break; }
2064				Expect(22, la); // ","
2065				currentState = 50;
2066				break;
2067			}
2068			case 50: {
2069				activeArgument++;
2070				goto case 51;
2071			}
2072			case 51: {
2073				nextTokenIsPotentialStartOfExpression = true;
2074				goto case 52;
2075			}
2076			case 52: {
2077				if (la == null) { currentState = 52; break; }
2078				if (set[23].Get(la.kind)) {
2079					stateStack.Push(53);
2080					goto case 55;
2081				} else {
2082					goto case 53;
2083				}
2084			}
2085			case 53: {
2086				if (la == null) { currentState = 53; break; }
2087				if (la.kind == 22) {
2088					currentState = 54;
2089					break;
2090				} else {
2091					currentState = stateStack.Pop();
2092					goto switchlbl;
2093				}
2094			}
2095			case 54: {
2096				activeArgument++;
2097				goto case 51;
2098			}
2099			case 55: {
2100				PushContext(Context.Expression, la, t);
2101				goto case 56;
2102			}
2103			case 56: {
2104				stateStack.Push(57);
2105				goto case 75;
2106			}
2107			case 57: {
2108				if (la == null) { currentState = 57; break; }
2109				if (set[25].Get(la.kind)) {
2110					stateStack.Push(56);
2111					goto case 58;
2112				} else {
2113					PopContext();
2114					currentState = stateStack.Pop();
2115					goto switchlbl;
2116				}
2117			}
2118			case 58: {
2119				if (la == null) { currentState = 58; break; }
2120				if (la.kind == 31) {
2121					currentState = stateStack.Pop();
2122					break;
2123				} else {
2124					if (la.kind == 30) {
2125						currentState = stateStack.Pop();
2126						break;
2127					} else {
2128						if (la.kind == 34) {
2129							currentState = stateStack.Pop();
2130							break;
2131						} else {
2132							if (la.kind == 25) {
2133								currentState = stateStack.Pop();
2134								break;
2135							} else {
2136								if (la.kind == 24) {
2137									currentState = stateStack.Pop();
2138									break;
2139								} else {
2140									if (la.kind == 32) {
2141										currentState = stateStack.Pop();
2142										break;
2143									} else {
2144										if (la.kind == 154) {
2145											goto case 74;
2146										} else {
2147											if (la.kind == 20) {
2148												goto case 73;
2149											} else {
2150												if (la.kind == 41) {
2151													goto case 72;
2152												} else {
2153													if (la.kind == 40) {
2154														goto case 71;
2155													} else {
2156														if (la.kind == 39) {
2157															currentState = 70;
2158															break;
2159														} else {
2160															if (la.kind == 43) {
2161																goto case 69;
2162															} else {
2163																if (la.kind == 42) {
2164																	goto case 68;
2165																} else {
2166																	if (la.kind == 150) {
2167																		goto case 67;
2168																	} else {
2169																		if (la.kind == 23) {
2170																			currentState = stateStack.Pop();
2171																			break;
2172																		} else {
2173																			if (la.kind == 60) {
2174																				goto case 66;
2175																			} else {
2176																				if (la.kind == 61) {
2177																					goto case 65;
2178																				} else {
2179																					if (la.kind == 175) {
2180																						goto case 64;
2181																					} else {
2182																						if (la.kind == 177) {
2183																							goto case 63;
2184																						} else {
2185																							if (la.kind == 236) {
2186																								goto case 62;
2187																							} else {
2188																								if (la.kind == 44) {
2189																									currentState = stateStack.Pop();
2190																									break;
2191																								} else {
2192																									if (la.kind == 45) {
2193																										currentState = stateStack.Pop();
2194																										break;
2195																									} else {
2196																										if (la.kind == 144) {
2197																											goto case 61;
2198																										} else {
2199																											if (la.kind == 145) {
2200																												goto case 60;
2201																											} else {
2202																												if (la.kind == 47) {
2203																													currentState = stateStack.Pop();
2204																													break;
2205																												} else {
2206																													if (la.kind == 49) {
2207																														currentState = stateStack.Pop();
2208																														break;
2209																													} else {
2210																														if (la.kind == 50) {
2211																															currentState = stateStack.Pop();
2212																															break;
2213																														} else {
2214																															if (la.kind == 51) {
2215																																currentState = stateStack.Pop();
2216																																break;
2217																															} else {
2218																																if (la.kind == 46) {
2219																																	currentState = stateStack.Pop();
2220																																	break;
2221																																} else {
2222																																	if (la.kind == 48) {
2223																																		currentState = stateStack.Pop();
2224																																		break;
2225																																	} else {
2226																																		if (la.kind == 54) {
2227																																			currentState = stateStack.Pop();
2228																																			break;
2229																																		} else {
2230																																			if (la.kind == 52) {
2231																																				currentState = stateStack.Pop();
2232																																				break;
2233																																			} else {
2234																																				if (la.kind == 53) {
2235																																					currentState = stateStack.Pop();
2236																																					break;
2237																																				} else {
2238																																					if (la.kind == 216) {
2239																																						goto case 59;
2240																																					} else {
2241																																						if (la.kind == 55) {
2242																																							currentState = stateStack.Pop();
2243																																							break;
2244																																						} else {
2245																																							goto case 6;
2246																																						}
2247																																					}
2248																																				}
2249																																			}
2250																																		}
2251																																	}
2252																																}
2253																															}
2254																														}
2255																													}
2256																												}
2257																											}
2258																										}
2259																									}
2260																								}
2261																							}
2262																						}
2263																					}
2264																				}
2265																			}
2266																		}
2267																	}
2268																}
2269															}
2270														}
2271													}
2272												}
2273											}
2274										}
2275									}
2276								}
2277							}
2278						}
2279					}
2280				}
2281			}
2282			case 59: {
2283				if (la == null) { currentState = 59; break; }
2284				currentState = stateStack.Pop();
2285				break;
2286			}
2287			case 60: {
2288				if (la == null) { currentState = 60; break; }
2289				currentState = stateStack.Pop();
2290				break;
2291			}
2292			case 61: {
2293				if (la == null) { currentState = 61; break; }
2294				currentState = stateStack.Pop();
2295				break;
2296			}
2297			case 62: {
2298				if (la == null) { currentState = 62; break; }
2299				currentState = stateStack.Pop();
2300				break;
2301			}
2302			case 63: {
2303				if (la == null) { currentState = 63; break; }
2304				currentState = stateStack.Pop();
2305				break;
2306			}
2307			case 64: {
2308				if (la == null) { currentState = 64; break; }
2309				currentState = stateStack.Pop();
2310				break;
2311			}
2312			case 65: {
2313				if (la == null) { currentState = 65; break; }
2314				currentState = stateStack.Pop();
2315				break;
2316			}
2317			case 66: {
2318				if (la == null) { currentState = 66; break; }
2319				currentState = stateStack.Pop();
2320				break;
2321			}
2322			case 67: {
2323				if (la == null) { currentState = 67; break; }
2324				currentState = stateStack.Pop();
2325				break;
2326			}
2327			case 68: {
2328				if (la == null) { currentState = 68; break; }
2329				currentState = stateStack.Pop();
2330				break;
2331			}
2332			case 69: {
2333				if (la == null) { currentState = 69; break; }
2334				currentState = stateStack.Pop();
2335				break;
2336			}
2337			case 70: {
2338				wasNormalAttribute = false;
2339				currentState = stateStack.Pop();
2340				goto switchlbl;
2341			}
2342			case 71: {
2343				if (la == null) { currentState = 71; break; }
2344				currentState = stateStack.Pop();
2345				break;
2346			}
2347			case 72: {
2348				if (la == null) { currentState = 72; break; }
2349				currentState = stateStack.Pop();
2350				break;
2351			}
2352			case 73: {
2353				if (la == null) { currentState = 73; break; }
2354				currentState = stateStack.Pop();
2355				break;
2356			}
2357			case 74: {
2358				if (la == null) { currentState = 74; break; }
2359				currentState = stateStack.Pop();
2360				break;
2361			}
2362			case 75: {
2363				PushContext(Context.Expression, la, t);
2364				goto case 76;
2365			}
2366			case 76: {
2367				nextTokenIsPotentialStartOfExpression = true;
2368				goto case 77;
2369			}
2370			case 77: {
2371				if (la == null) { currentState = 77; break; }
2372				if (set[135].Get(la.kind)) {
2373					currentState = 76;
2374					break;
2375				} else {
2376					if (set[35].Get(la.kind)) {
2377						stateStack.Push(159);
2378						goto case 173;
2379					} else {
2380						if (la.kind == 220) {
2381							currentState = 155;
2382							break;
2383						} else {
2384							if (la.kind == 162) {
2385								stateStack.Push(78);
2386								goto case 85;
2387							} else {
2388								if (la.kind == 35) {
2389									stateStack.Push(78);
2390									goto case 79;
2391								} else {
2392									Error(la);
2393									goto case 78;
2394								}
2395							}
2396						}
2397					}
2398				}
2399			}
2400			case 78: {
2401				PopContext();
2402				currentState = stateStack.Pop();
2403				goto switchlbl;
2404			}
2405			case 79: {
2406				if (la == null) { currentState = 79; break; }
2407				Expect(35, la); // "{"
2408				currentState = 80;
2409				break;
2410			}
2411			case 80: {
2412				nextTokenIsPotentialStartOfExpression = true;
2413				goto case 81;
2414			}
2415			case 81: {
2416				if (la == null) { currentState = 81; break; }
2417				if (set[23].Get(la.kind)) {
2418					goto case 83;
2419				} else {
2420					goto case 82;
2421				}
2422			}
2423			case 82: {
2424				if (la == null) { currentState = 82; break; }
2425				Expect(36, la); // "}"
2426				currentState = stateStack.Pop();
2427				break;
2428			}
2429			case 83: {
2430				stateStack.Push(84);
2431				goto case 55;
2432			}
2433			case 84: {
2434				if (la == null) { currentState = 84; break; }
2435				if (la.kind == 22) {
2436					currentState = 83;
2437					break;
2438				} else {
2439					goto case 82;
2440				}
2441			}
2442			case 85: {
2443				if (la == null) { currentState = 85; break; }
2444				Expect(162, la); // "New"
2445				currentState = 86;
2446				break;
2447			}
2448			case 86: {
2449				PushContext(Context.ObjectCreation, la, t);
2450				goto case 87;
2451			}
2452			case 87: {
2453				if (la == null) { currentState = 87; break; }
2454				if (set[16].Get(la.kind)) {
2455					stateStack.Push(146);
2456					goto case 37;
2457				} else {
2458					if (la.kind == 233) {
2459						PushContext(Context.ObjectInitializer, la, t);
2460						goto case 90;
2461					} else {
2462						goto case 88;
2463					}
2464				}
2465			}
2466			case 88: {
2467				Error(la);
2468				goto case 89;
2469			}
2470			case 89: {
2471				PopContext();
2472				currentState = stateStack.Pop();
2473				goto switchlbl;
2474			}
2475			case 90: {
2476				if (la == null) { currentState = 90; break; }
2477				Expect(233, la); // "With"
2478				currentState = 91;
2479				break;
2480			}
2481			case 91: {
2482				stateStack.Push(92);
2483				goto case 93;
2484			}
2485			case 92: {
2486				PopContext();
2487				goto case 89;
2488			}
2489			case 93: {
2490				if (la == null) { currentState = 93; break; }
2491				Expect(35, la); // "{"
2492				currentState = 94;
2493				break;
2494			}
2495			case 94: {
2496				if (la == null) { currentState = 94; break; }
2497				if (la.kind == 26 || la.kind == 147) {
2498					goto case 95;
2499				} else {
2500					goto case 82;
2501				}
2502			}
2503			case 95: {
2504				if (la == null) { currentState = 95; break; }
2505				if (la.kind == 147) {
2506					currentState = 96;
2507					break;
2508				} else {
2509					goto case 96;
2510				}
2511			}
2512			case 96: {
2513				if (la == null) { currentState = 96; break; }
2514				Expect(26, la); // "."
2515				currentState = 97;
2516				break;
2517			}
2518			case 97: {
2519				stateStack.Push(98);
2520				goto case 101;
2521			}
2522			case 98: {
2523				if (la == null) { currentState = 98; break; }
2524				Expect(20, la); // "="
2525				currentState = 99;
2526				break;
2527			}
2528			case 99: {
2529				stateStack.Push(100);
2530				goto case 55;
2531			}
2532			case 100: {
2533				if (la == null) { currentState = 100; break; }
2534				if (la.kind == 22) {
2535					currentState = 95;
2536					break;
2537				} else {
2538					goto case 82;
2539				}
2540			}
2541			case 101: {
2542				if (la == null) { currentState = 101; break; }
2543				if (la.kind == 2) {
2544					goto case 145;
2545				} else {
2546					if (la.kind == 56) {
2547						currentState = stateStack.Pop();
2548						break;
2549					} else {
2550						if (la.kind == 57) {
2551							currentState = stateStack.Pop();
2552							break;
2553						} else {
2554							if (la.kind == 58) {
2555								goto case 144;
2556							} else {
2557								if (la.kind == 59) {
2558									currentState = stateStack.Pop();
2559									break;
2560								} else {
2561									if (la.kind == 60) {
2562										goto case 66;
2563									} else {
2564										if (la.kind == 61) {
2565											goto case 65;
2566										} else {
2567											if (la.kind == 62) {
2568												goto case 143;
2569											} else {
2570												if (la.kind == 63) {
2571													currentState = stateStack.Pop();
2572													break;
2573												} else {
2574													if (la.kind == 64) {
2575														goto case 142;
2576													} else {
2577														if (la.kind == 65) {
2578															goto case 141;
2579														} else {
2580															if (la.kind == 66) {
2581																goto case 140;
2582															} else {
2583																if (la.kind == 67) {
2584																	goto case 139;
2585																} else {
2586																	if (la.kind == 68) {
2587																		currentState = stateStack.Pop();
2588																		break;
2589																	} else {
2590																		if (la.kind == 69) {
2591																			currentState = stateStack.Pop();
2592																			break;
2593																		} else {
2594																			if (la.kind == 70) {
2595																				goto case 138;
2596																			} else {
2597																				if (la.kind == 71) {
2598																					currentState = stateStack.Pop();
2599																					break;
2600																				} else {
2601																					if (la.kind == 72) {
2602																						currentState = stateStack.Pop();
2603																						break;
2604																					} else {
2605																						if (la.kind == 73) {
2606																							currentState = stateStack.Pop();
2607																							break;
2608																						} else {
2609																							if (la.kind == 74) {
2610																								currentState = stateStack.Pop();
2611																								break;
2612																							} else {
2613																								if (la.kind == 75) {
2614																									currentState = stateStack.Pop();
2615																									break;
2616																								} else {
2617																									if (la.kind == 76) {
2618																										currentState = stateStack.Pop();
2619																										break;
2620																									} else {
2621																										if (la.kind == 77) {
2622																											currentState = stateStack.Pop();
2623																											break;
2624																										} else {
2625																											if (la.kind == 78) {
2626																												currentState = stateStack.Pop();
2627																												break;
2628																											} else {
2629																												if (la.kind == 79) {
2630																													currentState = stateStack.Pop();
2631																													break;
2632																												} else {
2633																													if (la.kind == 80) {
2634																														currentState = stateStack.Pop();
2635																														break;
2636																													} else {
2637																														if (la.kind == 81) {
2638																															currentState = stateStack.Pop();
2639	…