diff --git a/src/AddIns/BackendBindings/VBNetBinding/Project/Src/CompletionDataHelper.cs b/src/AddIns/BackendBindings/VBNetBinding/Project/Src/CompletionDataHelper.cs
index ac38ad047e..8528ede62d 100644
--- a/src/AddIns/BackendBindings/VBNetBinding/Project/Src/CompletionDataHelper.cs
+++ b/src/AddIns/BackendBindings/VBNetBinding/Project/Src/CompletionDataHelper.cs
@@ -130,12 +130,12 @@ namespace ICSharpCode.VBNetBinding
static void AddSpecialItems(ref VBNetCompletionItemList result, ParseInformation info, IReturnType resolvedType, string word, IMember m, ExpressionResult expressionResult, ITextEditor editor)
{
-// if (expressionResult.Context == ExpressionContext.Type && m != null && m.BodyRegion.IsInside(editor.Caret.Line, editor.Caret.Column)) {
-// result.Items.Add(new DefaultCompletionItem("? =") {
-// Image = ClassBrowserIconService.GotoArrow,
-// Description = StringParser.Parse("${res:AddIns.VBNetBinding.CodeCompletion.QuestionmarkEqualsItem.Description}")
-// });
-// }
+ if (expressionResult.Context == ExpressionContext.Type && m != null && m.BodyRegion.IsInside(editor.Caret.Line, editor.Caret.Column)) {
+ result.Items.Add(new DefaultCompletionItem("? =") {
+ Image = ClassBrowserIconService.GotoArrow,
+ Description = StringParser.Parse("${res:AddIns.VBNetBinding.CodeCompletion.QuestionmarkEqualsItem.Description}")
+ });
+ }
if (resolvedType != null && AllowsDescendentAccess(resolvedType, info.CompilationUnit.ProjectContent))
result.Items.Add(new DefaultCompletionItem("..") { Image = ClassBrowserIconService.GotoArrow });
if (resolvedType != null && AllowsAttributeValueAccess(resolvedType, info.CompilationUnit.ProjectContent))
diff --git a/src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetCompletionBinding.cs b/src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetCompletionBinding.cs
index 30ac6888a8..32ee8243ab 100644
--- a/src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetCompletionBinding.cs
+++ b/src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetCompletionBinding.cs
@@ -66,6 +66,7 @@ namespace ICSharpCode.VBNetBinding
if (insightWindow != null) {
insightHandler.InitializeOpenedInsightWindow(editor, insightWindow);
insightHandler.HighlightParameter(insightWindow, 0);
+ insightWindow.CaretPositionChanged += delegate { Run(insightWindow, editor); };;
}
return CodeCompletionKeyPressResult.Completed;
}
@@ -77,6 +78,7 @@ namespace ICSharpCode.VBNetBinding
if (insightHandler.InsightRefreshOnComma(editor, ch, out insightWindow)) {
if (insightWindow != null) {
insightHandler.HighlightParameter(insightWindow, GetArgumentIndex(editor) + 1);
+ insightWindow.CaretPositionChanged += delegate { Run(insightWindow, editor); };;
}
return CodeCompletionKeyPressResult.EatKey;
}
@@ -136,6 +138,11 @@ namespace ICSharpCode.VBNetBinding
return CodeCompletionKeyPressResult.None;
}
+ void Run(IInsightWindow insightWindow, ITextEditor editor)
+ {
+ insightHandler.HighlightParameter(insightWindow, GetArgumentIndex(editor));
+ }
+
static int GetArgumentIndex(ITextEditor editor)
{
ILexer lexer = ParserFactory.CreateLexer(SupportedLanguage.VBNet, editor.Document.CreateReader());
@@ -143,7 +150,7 @@ namespace ICSharpCode.VBNetBinding
Token t = lexer.NextToken();
- while (t.Kind != Tokens.EOF && t.EndLocation < editor.Caret.Position) {
+ while (t.Kind != Tokens.EOF && t.Location < editor.Caret.Position) {
ef.InformToken(t);
t = lexer.NextToken();
}
diff --git a/src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/SharpDevelopInsightWindow.cs b/src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/SharpDevelopInsightWindow.cs
index 800873f190..d7059a1425 100644
--- a/src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/SharpDevelopInsightWindow.cs
+++ b/src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/SharpDevelopInsightWindow.cs
@@ -95,6 +95,10 @@ namespace ICSharpCode.AvalonEdit.AddIn
public SharpDevelopInsightWindow(TextArea textArea) : base(textArea)
{
this.Provider = new SDItemProvider(this);
+ this.Provider.PropertyChanged += delegate(object sender, PropertyChangedEventArgs e) {
+ if (e.PropertyName == "SelectedIndex")
+ OnSelectedItemChanged(EventArgs.Empty);
+ };
this.Style = ICSharpCode.Core.Presentation.GlobalStyles.WindowStyle;
AttachEvents();
}
@@ -113,16 +117,26 @@ namespace ICSharpCode.AvalonEdit.AddIn
}
set {
this.Provider.SelectedIndex = items.IndexOf(value);
+ OnSelectedItemChanged(EventArgs.Empty);
}
}
TextDocument document;
+ Caret caret;
void AttachEvents()
{
document = this.TextArea.Document;
+ caret = this.TextArea.Caret;
if (document != null)
document.Changed += document_Changed;
+ if (caret != null)
+ caret.PositionChanged += caret_PositionChanged;
+ }
+
+ void caret_PositionChanged(object sender, EventArgs e)
+ {
+ OnCaretPositionChanged(e);
}
///
@@ -130,6 +144,8 @@ namespace ICSharpCode.AvalonEdit.AddIn
{
if (document != null)
document.Changed -= document_Changed;
+ if (caret != null)
+ caret.PositionChanged -= caret_PositionChanged;
base.DetachEvents();
}
@@ -140,5 +156,23 @@ namespace ICSharpCode.AvalonEdit.AddIn
}
public event EventHandler DocumentChanged;
+
+ public event EventHandler SelectedItemChanged;
+
+ protected virtual void OnSelectedItemChanged(EventArgs e)
+ {
+ if (SelectedItemChanged != null) {
+ SelectedItemChanged(this, e);
+ }
+ }
+
+ public event EventHandler CaretPositionChanged;
+
+ protected virtual void OnCaretPositionChanged(EventArgs e)
+ {
+ if (CaretPositionChanged != null) {
+ CaretPositionChanged(this, e);
+ }
+ }
}
}
diff --git a/src/Libraries/NRefactory/Project/Src/Lexer/VBNet/ExpressionFinder.atg b/src/Libraries/NRefactory/Project/Src/Lexer/VBNet/ExpressionFinder.atg
index 4757115a05..b5072ec09c 100644
--- a/src/Libraries/NRefactory/Project/Src/Lexer/VBNet/ExpressionFinder.atg
+++ b/src/Libraries/NRefactory/Project/Src/Lexer/VBNet/ExpressionFinder.atg
@@ -1183,7 +1183,7 @@ InvocationStatement =
ArgumentList =
(. activeArgument = 0; .) Expression { "," (. activeArgument++; .) [ Expression ] }
-| "," [ Expression ] { "," [ Expression ] }
+| (. activeArgument = 0; .) "," (. activeArgument++; .) [ Expression ] { "," (. activeArgument++; .) [ Expression ] }
.
/* This production handles pseudo keywords that are needed in the grammar */
diff --git a/src/Libraries/NRefactory/Project/Src/Lexer/VBNet/Parser.cs b/src/Libraries/NRefactory/Project/Src/Lexer/VBNet/Parser.cs
index 0ad128349e..7bc83a7b3b 100644
--- a/src/Libraries/NRefactory/Project/Src/Lexer/VBNet/Parser.cs
+++ b/src/Libraries/NRefactory/Project/Src/Lexer/VBNet/Parser.cs
@@ -9,8 +9,8 @@ namespace ICSharpCode.NRefactory.Parser.VB {
partial class ExpressionFinder {
- const int startOfExpression = 49;
- const int endOfStatementTerminatorAndBlock = 226;
+ const int startOfExpression = 51;
+ const int endOfStatementTerminatorAndBlock = 228;
static BitArray GetExpectedSet(int state)
{
switch (state) {
@@ -25,9 +25,9 @@ partial class ExpressionFinder {
case 5:
return set[3];
case 6:
- case 64:
- case 227:
- case 458:
+ case 66:
+ case 229:
+ case 460:
{
BitArray a = new BitArray(239);
return a;
@@ -37,29 +37,29 @@ partial class ExpressionFinder {
case 8:
return set[5];
case 9:
- case 155:
- case 161:
- case 167:
- case 204:
- case 208:
- case 247:
- case 347:
- case 356:
- case 409:
- case 448:
- case 456:
- case 464:
- case 487:
- case 522:
- case 576:
- case 590:
- case 659:
+ case 157:
+ case 163:
+ case 169:
+ case 206:
+ case 210:
+ case 249:
+ case 349:
+ case 358:
+ case 411:
+ case 450:
+ case 458:
+ case 466:
+ case 489:
+ case 524:
+ case 578:
+ case 592:
+ case 661:
return set[6];
case 10:
- case 488:
- case 489:
- case 533:
- case 543:
+ case 490:
+ case 491:
+ case 535:
+ case 545:
{
BitArray a = new BitArray(239);
a.Set(1, true);
@@ -71,40 +71,40 @@ partial class ExpressionFinder {
case 18:
case 19:
case 31:
- case 219:
- case 222:
- case 223:
- case 233:
- case 248:
- case 252:
- case 274:
- case 289:
- case 300:
- case 303:
- case 309:
- case 314:
- case 323:
- case 324:
- case 344:
- case 364:
- case 466:
- case 481:
- case 490:
- case 499:
- case 516:
- case 520:
- case 528:
- case 534:
- case 537:
- case 544:
- case 547:
- case 571:
- case 574:
- case 598:
- case 608:
- case 612:
- case 637:
- case 658:
+ case 221:
+ case 224:
+ case 225:
+ case 235:
+ case 250:
+ case 254:
+ case 276:
+ case 291:
+ case 302:
+ case 305:
+ case 311:
+ case 316:
+ case 325:
+ case 326:
+ case 346:
+ case 366:
+ case 468:
+ case 483:
+ case 492:
+ case 501:
+ case 518:
+ case 522:
+ case 530:
+ case 536:
+ case 539:
+ case 546:
+ case 549:
+ case 573:
+ case 576:
+ case 600:
+ case 610:
+ case 614:
+ case 639:
+ case 660:
{
BitArray a = new BitArray(239);
a.Set(1, true);
@@ -118,26 +118,26 @@ partial class ExpressionFinder {
case 15:
return set[8];
case 16:
- case 220:
- case 234:
- case 250:
- case 304:
- case 345:
- case 389:
- case 497:
- case 517:
- case 535:
- case 539:
- case 545:
- case 572:
- case 609:
+ case 222:
+ case 236:
+ case 252:
+ case 306:
+ case 347:
+ case 391:
+ case 499:
+ case 519:
+ case 537:
+ case 541:
+ case 547:
+ case 574:
+ case 611:
{
BitArray a = new BitArray(239);
a.Set(113, true);
return a;
}
case 17:
- case 462:
+ case 464:
{
BitArray a = new BitArray(239);
a.Set(142, true);
@@ -153,7 +153,7 @@ partial class ExpressionFinder {
case 22:
return set[9];
case 23:
- case 641:
+ case 643:
return set[10];
case 24:
return set[11];
@@ -161,61 +161,61 @@ partial class ExpressionFinder {
return set[12];
case 26:
case 27:
- case 120:
- case 177:
- case 178:
- case 228:
- case 379:
- case 380:
- case 397:
- case 398:
+ case 122:
+ case 179:
+ case 180:
+ case 230:
+ case 381:
+ case 382:
case 399:
case 400:
- case 475:
- case 476:
- case 509:
- case 510:
- case 604:
- case 605:
- case 651:
- case 652:
- return set[13];
- case 28:
- case 29:
- case 449:
- case 457:
+ case 401:
+ case 402:
case 477:
case 478:
- case 595:
+ case 511:
+ case 512:
case 606:
case 607:
+ case 653:
+ case 654:
+ return set[13];
+ case 28:
+ case 29:
+ case 451:
+ case 459:
+ case 479:
+ case 480:
+ case 597:
+ case 608:
+ case 609:
return set[14];
case 30:
case 32:
- case 124:
- case 134:
- case 150:
- case 165:
- case 181:
- case 259:
- case 284:
- case 363:
- case 376:
- case 412:
- case 452:
- case 472:
- case 480:
- case 556:
- case 580:
- case 585:
- case 597:
- case 611:
- case 630:
- case 633:
- case 636:
- case 643:
- case 646:
- case 664:
+ case 126:
+ case 136:
+ case 152:
+ case 167:
+ case 183:
+ case 261:
+ case 286:
+ case 365:
+ case 378:
+ case 414:
+ case 454:
+ case 474:
+ case 482:
+ case 558:
+ case 582:
+ case 587:
+ case 599:
+ case 613:
+ case 632:
+ case 635:
+ case 638:
+ case 645:
+ case 648:
+ case 666:
return set[15];
case 33:
case 36:
@@ -223,23 +223,23 @@ partial class ExpressionFinder {
case 34:
return set[17];
case 35:
- case 70:
- case 74:
- case 129:
- case 339:
- case 415:
+ case 72:
+ case 76:
+ case 131:
+ case 341:
+ case 417:
return set[18];
case 37:
- case 140:
- case 147:
- case 151:
- case 213:
- case 383:
- case 408:
- case 411:
- case 511:
- case 512:
- case 568:
+ case 142:
+ case 149:
+ case 153:
+ case 215:
+ case 385:
+ case 410:
+ case 413:
+ case 513:
+ case 514:
+ case 570:
{
BitArray a = new BitArray(239);
a.Set(37, true);
@@ -247,29 +247,29 @@ partial class ExpressionFinder {
}
case 38:
case 39:
- case 131:
- case 132:
+ case 133:
+ case 134:
return set[19];
case 40:
- case 133:
- case 216:
- case 361:
- case 386:
- case 410:
- case 426:
- case 455:
- case 461:
- case 484:
- case 514:
- case 550:
- case 553:
- case 562:
- case 570:
- case 584:
- case 601:
- case 615:
- case 640:
- case 650:
+ case 135:
+ case 218:
+ case 363:
+ case 388:
+ case 412:
+ case 428:
+ case 457:
+ case 463:
+ case 486:
+ case 516:
+ case 552:
+ case 555:
+ case 564:
+ case 572:
+ case 586:
+ case 603:
+ case 617:
+ case 642:
+ case 652:
{
BitArray a = new BitArray(239);
a.Set(38, true);
@@ -279,529 +279,531 @@ partial class ExpressionFinder {
case 42:
case 46:
case 47:
- case 420:
- case 421:
+ case 48:
+ case 50:
+ case 422:
+ case 423:
return set[20];
case 43:
case 44:
return set[21];
case 45:
- case 142:
- case 149:
- case 342:
+ case 144:
+ case 151:
+ case 344:
{
BitArray a = new BitArray(239);
a.Set(22, true);
return a;
}
- case 48:
- case 135:
- case 144:
- case 360:
+ case 49:
+ case 137:
+ case 146:
case 362:
- case 366:
- case 374:
- case 419:
- case 423:
- case 433:
- case 440:
- case 447:
+ case 364:
+ case 368:
+ case 376:
+ case 421:
+ case 425:
+ case 435:
+ case 442:
+ case 449:
{
BitArray a = new BitArray(239);
a.Set(22, true);
a.Set(38, true);
return a;
}
- case 49:
- case 50:
+ case 51:
case 52:
- case 53:
case 54:
- case 57:
- case 72:
- case 122:
- case 141:
+ case 55:
+ case 56:
+ case 59:
+ case 74:
+ case 124:
case 143:
case 145:
- case 148:
- case 157:
+ case 147:
+ case 150:
case 159:
- case 199:
- case 232:
- case 236:
+ case 161:
+ case 201:
+ case 234:
case 238:
- case 239:
- case 256:
- case 273:
- case 278:
- case 287:
- case 293:
+ case 240:
+ case 241:
+ case 258:
+ case 275:
+ case 280:
+ case 289:
case 295:
- case 299:
- case 302:
- case 308:
- case 319:
+ case 297:
+ case 301:
+ case 304:
+ case 310:
case 321:
- case 327:
- case 341:
+ case 323:
+ case 329:
case 343:
- case 375:
- case 402:
- case 417:
- case 418:
- case 471:
- case 555:
+ case 345:
+ case 377:
+ case 404:
+ case 419:
+ case 420:
+ case 473:
+ case 557:
return set[22];
- case 51:
- case 55:
+ case 53:
+ case 57:
return set[23];
- case 56:
- case 66:
- case 67:
+ case 58:
+ case 68:
+ case 69:
{
BitArray a = new BitArray(239);
a.Set(35, true);
return a;
}
- case 58:
- case 73:
- case 443:
+ case 60:
+ case 75:
+ case 445:
{
BitArray a = new BitArray(239);
a.Set(22, true);
a.Set(36, true);
return a;
}
- case 59:
+ case 61:
{
BitArray a = new BitArray(239);
a.Set(36, true);
return a;
}
- case 60:
- case 94:
+ case 62:
+ case 96:
{
BitArray a = new BitArray(239);
a.Set(162, true);
return a;
}
- case 61:
- case 62:
- return set[24];
case 63:
- case 75:
+ case 64:
+ return set[24];
+ case 65:
+ case 77:
{
BitArray a = new BitArray(239);
a.Set(233, true);
return a;
}
- case 65:
+ case 67:
return set[25];
- case 68:
+ case 70:
{
BitArray a = new BitArray(239);
a.Set(26, true);
a.Set(147, true);
return a;
}
- case 69:
+ case 71:
{
BitArray a = new BitArray(239);
a.Set(26, true);
return a;
}
- case 71:
- case 180:
+ case 73:
case 182:
- case 183:
- case 286:
- case 660:
+ case 184:
+ case 185:
+ case 288:
+ case 662:
{
BitArray a = new BitArray(239);
a.Set(20, true);
return a;
}
- case 76:
- case 305:
+ case 78:
+ case 307:
{
BitArray a = new BitArray(239);
a.Set(231, true);
return a;
}
- case 77:
+ case 79:
{
BitArray a = new BitArray(239);
a.Set(230, true);
return a;
}
- case 78:
+ case 80:
{
BitArray a = new BitArray(239);
a.Set(224, true);
return a;
}
- case 79:
+ case 81:
{
BitArray a = new BitArray(239);
a.Set(223, true);
return a;
}
- case 80:
- case 251:
+ case 82:
+ case 253:
{
BitArray a = new BitArray(239);
a.Set(218, true);
return a;
}
- case 81:
+ case 83:
{
BitArray a = new BitArray(239);
a.Set(213, true);
return a;
}
- case 82:
+ case 84:
{
BitArray a = new BitArray(239);
a.Set(212, true);
return a;
}
- case 83:
+ case 85:
{
BitArray a = new BitArray(239);
a.Set(211, true);
return a;
}
- case 84:
- case 390:
+ case 86:
+ case 392:
{
BitArray a = new BitArray(239);
a.Set(210, true);
return a;
}
- case 85:
+ case 87:
{
BitArray a = new BitArray(239);
a.Set(209, true);
return a;
}
- case 86:
+ case 88:
{
BitArray a = new BitArray(239);
a.Set(206, true);
return a;
}
- case 87:
+ case 89:
{
BitArray a = new BitArray(239);
a.Set(203, true);
return a;
}
- case 88:
- case 311:
+ case 90:
+ case 313:
{
BitArray a = new BitArray(239);
a.Set(197, true);
return a;
}
- case 89:
- case 521:
- case 540:
+ case 91:
+ case 523:
+ case 542:
{
BitArray a = new BitArray(239);
a.Set(186, true);
return a;
}
- case 90:
+ case 92:
{
BitArray a = new BitArray(239);
a.Set(184, true);
return a;
}
- case 91:
+ case 93:
{
BitArray a = new BitArray(239);
a.Set(176, true);
return a;
}
- case 92:
+ case 94:
{
BitArray a = new BitArray(239);
a.Set(170, true);
return a;
}
- case 93:
- case 268:
- case 275:
- case 290:
+ case 95:
+ case 270:
+ case 277:
+ case 292:
{
BitArray a = new BitArray(239);
a.Set(163, true);
return a;
}
- case 95:
+ case 97:
{
BitArray a = new BitArray(239);
a.Set(147, true);
return a;
}
- case 96:
- case 186:
- case 191:
+ case 98:
+ case 188:
case 193:
+ case 195:
{
BitArray a = new BitArray(239);
a.Set(146, true);
return a;
}
- case 97:
- case 188:
- case 192:
+ case 99:
+ case 190:
+ case 194:
{
BitArray a = new BitArray(239);
a.Set(143, true);
return a;
}
- case 98:
+ case 100:
{
BitArray a = new BitArray(239);
a.Set(139, true);
return a;
}
- case 99:
+ case 101:
{
BitArray a = new BitArray(239);
a.Set(133, true);
return a;
}
- case 100:
- case 221:
+ case 102:
+ case 223:
{
BitArray a = new BitArray(239);
a.Set(127, true);
return a;
}
- case 101:
- case 211:
+ case 103:
+ case 213:
{
BitArray a = new BitArray(239);
a.Set(126, true);
return a;
}
- case 102:
+ case 104:
{
BitArray a = new BitArray(239);
a.Set(124, true);
return a;
}
- case 103:
+ case 105:
{
BitArray a = new BitArray(239);
a.Set(121, true);
return a;
}
- case 104:
- case 158:
+ case 106:
+ case 160:
{
BitArray a = new BitArray(239);
a.Set(116, true);
return a;
}
- case 105:
+ case 107:
{
BitArray a = new BitArray(239);
a.Set(108, true);
return a;
}
- case 106:
+ case 108:
{
BitArray a = new BitArray(239);
a.Set(107, true);
return a;
}
- case 107:
+ case 109:
{
BitArray a = new BitArray(239);
a.Set(104, true);
return a;
}
- case 108:
- case 563:
+ case 110:
+ case 565:
{
BitArray a = new BitArray(239);
a.Set(98, true);
return a;
}
- case 109:
+ case 111:
{
BitArray a = new BitArray(239);
a.Set(87, true);
return a;
}
- case 110:
+ case 112:
{
BitArray a = new BitArray(239);
a.Set(84, true);
return a;
}
- case 111:
- case 170:
- case 198:
+ case 113:
+ case 172:
+ case 200:
{
BitArray a = new BitArray(239);
a.Set(70, true);
return a;
}
- case 112:
+ case 114:
{
BitArray a = new BitArray(239);
a.Set(67, true);
return a;
}
- case 113:
+ case 115:
{
BitArray a = new BitArray(239);
a.Set(66, true);
return a;
}
- case 114:
+ case 116:
{
BitArray a = new BitArray(239);
a.Set(65, true);
return a;
}
- case 115:
+ case 117:
{
BitArray a = new BitArray(239);
a.Set(64, true);
return a;
}
- case 116:
+ case 118:
{
BitArray a = new BitArray(239);
a.Set(62, true);
return a;
}
- case 117:
- case 210:
+ case 119:
+ case 212:
{
BitArray a = new BitArray(239);
a.Set(58, true);
return a;
}
- case 118:
+ case 120:
{
BitArray a = new BitArray(239);
a.Set(2, true);
return a;
}
- case 119:
- return set[26];
case 121:
- return set[27];
+ return set[26];
case 123:
+ return set[27];
+ case 125:
{
BitArray a = new BitArray(239);
a.Set(144, true);
return a;
}
- case 125:
- return set[28];
- case 126:
- return set[29];
case 127:
+ return set[28];
case 128:
- case 413:
- case 414:
- return set[30];
+ return set[29];
+ case 129:
case 130:
+ case 415:
+ case 416:
+ return set[30];
+ case 132:
return set[31];
- case 136:
- case 137:
- case 271:
- case 280:
- return set[32];
case 138:
- case 392:
- return set[33];
case 139:
- case 326:
+ case 273:
+ case 282:
+ return set[32];
+ case 140:
+ case 394:
+ return set[33];
+ case 141:
+ case 328:
{
BitArray a = new BitArray(239);
a.Set(135, true);
return a;
}
- case 146:
+ case 148:
return set[34];
- case 152:
+ case 154:
{
BitArray a = new BitArray(239);
a.Set(58, true);
a.Set(126, true);
return a;
}
- case 153:
- case 154:
- return set[35];
+ case 155:
case 156:
+ return set[35];
+ case 158:
{
BitArray a = new BitArray(239);
a.Set(171, true);
return a;
}
- case 160:
- case 174:
- case 190:
- case 195:
- case 201:
+ case 162:
+ case 176:
+ case 192:
+ case 197:
case 203:
- case 207:
+ case 205:
case 209:
+ case 211:
return set[36];
- case 162:
- case 163:
+ case 164:
+ case 165:
{
BitArray a = new BitArray(239);
a.Set(63, true);
a.Set(138, true);
return a;
}
- case 164:
case 166:
- case 272:
+ case 168:
+ case 274:
{
BitArray a = new BitArray(239);
a.Set(138, true);
return a;
}
- case 168:
- case 169:
+ case 170:
case 171:
case 173:
case 175:
- case 176:
- case 184:
- case 189:
- case 194:
- case 202:
- case 206:
+ case 177:
+ case 178:
+ case 186:
+ case 191:
+ case 196:
+ case 204:
+ case 208:
return set[37];
- case 172:
+ case 174:
{
BitArray a = new BitArray(239);
a.Set(22, true);
a.Set(143, true);
return a;
}
- case 179:
+ case 181:
return set[38];
- case 185:
+ case 187:
{
BitArray a = new BitArray(239);
a.Set(22, true);
a.Set(70, true);
return a;
}
- case 187:
+ case 189:
{
BitArray a = new BitArray(239);
a.Set(133, true);
@@ -809,86 +811,86 @@ partial class ExpressionFinder {
a.Set(146, true);
return a;
}
- case 196:
- case 197:
+ case 198:
+ case 199:
return set[39];
- case 200:
+ case 202:
{
BitArray a = new BitArray(239);
a.Set(64, true);
a.Set(104, true);
return a;
}
- case 205:
- return set[40];
- case 212:
- case 474:
- case 589:
- case 603:
- case 610:
+ case 207:
+ return set[40];
+ case 214:
+ case 476:
+ case 591:
+ case 605:
+ case 612:
{
BitArray a = new BitArray(239);
a.Set(127, true);
a.Set(210, true);
return a;
}
- case 214:
- case 215:
- case 384:
- case 385:
- case 453:
- case 454:
- case 459:
- case 460:
- case 482:
- case 483:
- case 548:
- case 549:
+ case 216:
+ case 217:
+ case 386:
+ case 387:
+ case 455:
+ case 456:
+ case 461:
+ case 462:
+ case 484:
+ case 485:
+ case 550:
case 551:
- case 552:
- case 560:
- case 561:
- case 582:
- case 583:
- case 599:
- case 600:
+ case 553:
+ case 554:
+ case 562:
+ case 563:
+ case 584:
+ case 585:
+ case 601:
+ case 602:
return set[41];
- case 217:
- case 218:
+ case 219:
+ case 220:
return set[42];
- case 224:
- case 225:
- return set[43];
case 226:
+ case 227:
+ return set[43];
+ case 228:
return set[44];
- case 229:
- return set[45];
- case 230:
case 231:
- case 332:
+ return set[45];
+ case 232:
+ case 233:
+ case 334:
return set[46];
- case 235:
+ case 237:
{
BitArray a = new BitArray(239);
a.Set(226, true);
return a;
}
- case 237:
+ case 239:
+ case 281:
+ case 296:
+ return set[47];
+ case 242:
+ case 243:
+ case 263:
+ case 264:
+ case 278:
case 279:
+ case 293:
case 294:
- return set[47];
- case 240:
- case 241:
- case 261:
- case 262:
- case 276:
- case 277:
- case 291:
- case 292:
return set[48];
- case 242:
- case 333:
- case 336:
+ case 244:
+ case 335:
+ case 338:
{
BitArray a = new BitArray(239);
a.Set(1, true);
@@ -896,7 +898,7 @@ partial class ExpressionFinder {
a.Set(111, true);
return a;
}
- case 243:
+ case 245:
{
BitArray a = new BitArray(239);
a.Set(108, true);
@@ -904,18 +906,18 @@ partial class ExpressionFinder {
a.Set(231, true);
return a;
}
- case 244:
+ case 246:
return set[49];
- case 245:
- case 264:
+ case 247:
+ case 266:
return set[50];
- case 246:
+ case 248:
{
BitArray a = new BitArray(239);
a.Set(5, true);
return a;
}
- case 249:
+ case 251:
{
BitArray a = new BitArray(239);
a.Set(75, true);
@@ -923,11 +925,11 @@ partial class ExpressionFinder {
a.Set(123, true);
return a;
}
- case 253:
- case 254:
- return set[51];
case 255:
- case 260:
+ case 256:
+ return set[51];
+ case 257:
+ case 262:
{
BitArray a = new BitArray(239);
a.Set(1, true);
@@ -935,36 +937,36 @@ partial class ExpressionFinder {
a.Set(229, true);
return a;
}
- case 257:
- case 258:
+ case 259:
+ case 260:
return set[52];
- case 263:
- return set[53];
case 265:
+ return set[53];
+ case 267:
{
BitArray a = new BitArray(239);
a.Set(118, true);
return a;
}
- case 266:
- case 267:
- return set[54];
+ case 268:
case 269:
- case 270:
+ return set[54];
+ case 271:
+ case 272:
return set[55];
- case 281:
- case 282:
- return set[56];
case 283:
- return set[57];
+ case 284:
+ return set[56];
case 285:
+ return set[57];
+ case 287:
{
BitArray a = new BitArray(239);
a.Set(20, true);
a.Set(138, true);
return a;
}
- case 288:
+ case 290:
{
BitArray a = new BitArray(239);
a.Set(1, true);
@@ -972,42 +974,42 @@ partial class ExpressionFinder {
a.Set(205, true);
return a;
}
- case 296:
+ case 298:
return set[58];
- case 297:
- case 301:
+ case 299:
+ case 303:
{
BitArray a = new BitArray(239);
a.Set(152, true);
return a;
}
- case 298:
+ case 300:
return set[59];
- case 306:
- case 307:
+ case 308:
+ case 309:
return set[60];
- case 310:
+ case 312:
{
BitArray a = new BitArray(239);
a.Set(74, true);
a.Set(113, true);
return a;
}
- case 312:
- case 313:
- return set[61];
+ case 314:
case 315:
- case 316:
- return set[62];
+ return set[61];
case 317:
- case 581:
- case 618:
- case 631:
- case 632:
+ case 318:
+ return set[62];
+ case 319:
+ case 583:
+ case 620:
+ case 633:
case 634:
- case 644:
- case 645:
+ case 636:
+ case 646:
case 647:
+ case 649:
{
BitArray a = new BitArray(239);
a.Set(1, true);
@@ -1015,11 +1017,11 @@ partial class ExpressionFinder {
a.Set(22, true);
return a;
}
- case 318:
case 320:
- return set[63];
case 322:
- case 328:
+ return set[63];
+ case 324:
+ case 330:
{
BitArray a = new BitArray(239);
a.Set(1, true);
@@ -1027,7 +1029,7 @@ partial class ExpressionFinder {
a.Set(214, true);
return a;
}
- case 325:
+ case 327:
{
BitArray a = new BitArray(239);
a.Set(111, true);
@@ -1035,7 +1037,7 @@ partial class ExpressionFinder {
a.Set(113, true);
return a;
}
- case 329:
+ case 331:
{
BitArray a = new BitArray(239);
a.Set(1, true);
@@ -1043,57 +1045,57 @@ partial class ExpressionFinder {
a.Set(135, true);
return a;
}
- case 330:
- case 331:
- case 387:
- case 388:
+ case 332:
+ case 333:
+ case 389:
+ case 390:
return set[64];
- case 334:
- case 335:
+ case 336:
case 337:
- case 338:
- return set[65];
+ case 339:
case 340:
+ return set[65];
+ case 342:
return set[66];
- case 346:
+ case 348:
{
BitArray a = new BitArray(239);
a.Set(211, true);
a.Set(233, true);
return a;
}
- case 348:
- case 349:
- case 357:
- case 358:
- return set[67];
case 350:
- case 359:
- return set[68];
case 351:
- return set[69];
+ case 359:
+ case 360:
+ return set[67];
case 352:
- case 355:
- return set[70];
+ case 361:
+ return set[68];
case 353:
+ return set[69];
case 354:
- case 624:
- case 625:
+ case 357:
+ return set[70];
+ case 355:
+ case 356:
+ case 626:
+ case 627:
return set[71];
- case 365:
case 367:
- case 368:
- case 513:
- case 569:
- return set[72];
case 369:
case 370:
- return set[73];
+ case 515:
+ case 571:
+ return set[72];
case 371:
case 372:
- return set[74];
+ return set[73];
case 373:
- case 377:
+ case 374:
+ return set[74];
+ case 375:
+ case 379:
{
BitArray a = new BitArray(239);
a.Set(20, true);
@@ -1101,72 +1103,72 @@ partial class ExpressionFinder {
a.Set(38, true);
return a;
}
- case 378:
+ case 380:
{
BitArray a = new BitArray(239);
a.Set(40, true);
return a;
}
- case 381:
- case 382:
- return set[75];
- case 391:
- return set[76];
- case 393:
- case 406:
- return set[77];
- case 394:
- case 407:
- return set[78];
+ case 383:
+ case 384:
+ return set[75];
+ case 393:
+ return set[76];
case 395:
+ case 408:
+ return set[77];
case 396:
+ case 409:
+ return set[78];
+ case 397:
+ case 398:
{
BitArray a = new BitArray(239);
a.Set(10, true);
return a;
}
- case 401:
+ case 403:
{
BitArray a = new BitArray(239);
a.Set(12, true);
return a;
}
- case 403:
+ case 405:
{
BitArray a = new BitArray(239);
a.Set(13, true);
return a;
}
- case 404:
+ case 406:
return set[79];
- case 405:
+ case 407:
return set[80];
- case 416:
+ case 418:
return set[81];
- case 422:
- return set[82];
case 424:
- case 425:
- case 613:
- case 614:
- return set[83];
+ return set[82];
+ case 426:
case 427:
- case 428:
- case 429:
- case 434:
- case 435:
+ case 615:
case 616:
- case 639:
- case 649:
- return set[84];
+ return set[83];
+ case 429:
case 430:
- case 436:
- case 445:
- return set[85];
case 431:
- case 432:
+ case 436:
case 437:
+ case 618:
+ case 641:
+ case 651:
+ return set[84];
+ case 432:
case 438:
+ case 447:
+ return set[85];
+ case 433:
+ case 434:
+ case 439:
+ case 440:
{
BitArray a = new BitArray(239);
a.Set(22, true);
@@ -1174,18 +1176,18 @@ partial class ExpressionFinder {
a.Set(63, true);
return a;
}
- case 439:
case 441:
- case 446:
+ case 443:
+ case 448:
return set[86];
- case 442:
case 444:
+ case 446:
return set[87];
- case 450:
- case 465:
- case 479:
- case 515:
- case 596:
+ case 452:
+ case 467:
+ case 481:
+ case 517:
+ case 598:
{
BitArray a = new BitArray(239);
a.Set(1, true);
@@ -1193,22 +1195,22 @@ partial class ExpressionFinder {
a.Set(63, true);
return a;
}
- case 451:
- case 519:
+ case 453:
+ case 521:
return set[88];
- case 463:
- case 468:
+ case 465:
+ case 470:
{
BitArray a = new BitArray(239);
a.Set(115, true);
return a;
}
- case 467:
- return set[89];
case 469:
+ return set[89];
+ case 471:
return set[90];
- case 470:
- case 527:
+ case 472:
+ case 529:
{
BitArray a = new BitArray(239);
a.Set(1, true);
@@ -1216,15 +1218,15 @@ partial class ExpressionFinder {
a.Set(21, true);
return a;
}
- case 473:
+ case 475:
{
BitArray a = new BitArray(239);
a.Set(103, true);
return a;
}
- case 485:
- case 486:
- case 498:
+ case 487:
+ case 488:
+ case 500:
{
BitArray a = new BitArray(239);
a.Set(84, true);
@@ -1232,83 +1234,83 @@ partial class ExpressionFinder {
a.Set(209, true);
return a;
}
- case 491:
- case 492:
- return set[91];
case 493:
case 494:
- return set[92];
+ return set[91];
case 495:
case 496:
- case 507:
+ return set[92];
+ case 497:
+ case 498:
+ case 509:
return set[93];
- case 500:
- return set[94];
- case 501:
case 502:
- return set[95];
+ return set[94];
case 503:
case 504:
- case 628:
- return set[96];
+ return set[95];
case 505:
- return set[97];
case 506:
- return set[98];
+ case 630:
+ return set[96];
+ case 507:
+ return set[97];
case 508:
- case 518:
+ return set[98];
+ case 510:
+ case 520:
{
BitArray a = new BitArray(239);
a.Set(172, true);
return a;
}
- case 523:
- case 524:
- return set[99];
case 525:
- return set[100];
case 526:
- case 559:
+ return set[99];
+ case 527:
+ return set[100];
+ case 528:
+ case 561:
return set[101];
- case 529:
- case 530:
case 531:
- case 554:
- return set[102];
case 532:
- case 536:
- case 546:
+ case 533:
+ case 556:
+ return set[102];
+ case 534:
+ case 538:
+ case 548:
{
BitArray a = new BitArray(239);
a.Set(128, true);
a.Set(198, true);
return a;
}
- case 538:
+ case 540:
return set[103];
- case 541:
+ case 543:
return set[104];
- case 542:
+ case 544:
return set[105];
- case 557:
- case 623:
- case 626:
+ case 559:
+ case 625:
+ case 628:
return set[106];
- case 558:
+ case 560:
return set[107];
- case 564:
case 566:
- case 575:
+ case 568:
+ case 577:
{
BitArray a = new BitArray(239);
a.Set(119, true);
return a;
}
- case 565:
- return set[108];
case 567:
+ return set[108];
+ case 569:
return set[109];
- case 573:
+ case 575:
{
BitArray a = new BitArray(239);
a.Set(56, true);
@@ -1316,11 +1318,11 @@ partial class ExpressionFinder {
a.Set(193, true);
return a;
}
- case 577:
- case 578:
- return set[110];
case 579:
- case 586:
+ case 580:
+ return set[110];
+ case 581:
+ case 588:
{
BitArray a = new BitArray(239);
a.Set(1, true);
@@ -1328,101 +1330,101 @@ partial class ExpressionFinder {
a.Set(136, true);
return a;
}
- case 587:
+ case 589:
{
BitArray a = new BitArray(239);
a.Set(101, true);
return a;
}
- case 588:
+ case 590:
return set[111];
- case 591:
- case 592:
+ case 593:
+ case 594:
{
BitArray a = new BitArray(239);
a.Set(149, true);
return a;
}
- case 593:
- case 602:
- case 661:
+ case 595:
+ case 604:
+ case 663:
{
BitArray a = new BitArray(239);
a.Set(3, true);
return a;
}
- case 594:
+ case 596:
return set[112];
- case 617:
case 619:
- return set[113];
- case 620:
- case 627:
- return set[114];
case 621:
+ return set[113];
case 622:
- return set[115];
case 629:
+ return set[114];
+ case 623:
+ case 624:
+ return set[115];
+ case 631:
{
BitArray a = new BitArray(239);
a.Set(136, true);
return a;
}
- case 635:
- case 642:
+ case 637:
+ case 644:
{
BitArray a = new BitArray(239);
a.Set(140, true);
return a;
}
- case 638:
- case 648:
+ case 640:
+ case 650:
{
BitArray a = new BitArray(239);
a.Set(169, true);
return a;
}
- case 653:
+ case 655:
return set[116];
- case 654:
+ case 656:
{
BitArray a = new BitArray(239);
a.Set(160, true);
return a;
}
- case 655:
+ case 657:
{
BitArray a = new BitArray(239);
a.Set(137, true);
return a;
}
- case 656:
- case 657:
+ case 658:
+ case 659:
return set[117];
- case 662:
+ case 664:
{
BitArray a = new BitArray(239);
a.Set(11, true);
return a;
}
- case 663:
- return set[118];
case 665:
+ return set[118];
+ case 667:
{
BitArray a = new BitArray(239);
a.Set(173, true);
return a;
}
- case 666:
+ case 668:
return set[119];
- case 667:
+ case 669:
{
BitArray a = new BitArray(239);
a.Set(67, true);
a.Set(213, true);
return a;
}
- case 668:
+ case 670:
return set[120];
default: throw new InvalidOperationException();
}
@@ -1477,7 +1479,7 @@ partial class ExpressionFinder {
if (la == null) { currentState = 1; break; }
if (la.kind == 173) {
stateStack.Push(1);
- goto case 665;
+ goto case 667;
} else {
goto case 2;
}
@@ -1486,7 +1488,7 @@ partial class ExpressionFinder {
if (la == null) { currentState = 2; break; }
if (la.kind == 137) {
stateStack.Push(2);
- goto case 655;
+ goto case 657;
} else {
goto case 3;
}
@@ -1495,7 +1497,7 @@ partial class ExpressionFinder {
if (la == null) { currentState = 3; break; }
if (la.kind == 40) {
stateStack.Push(3);
- goto case 378;
+ goto case 380;
} else {
goto case 4;
}
@@ -1514,7 +1516,7 @@ partial class ExpressionFinder {
case 5: {
if (la == null) { currentState = 5; break; }
if (la.kind == 160) {
- currentState = 651;
+ currentState = 653;
break;
} else {
if (set[4].Get(la.kind)) {
@@ -1533,7 +1535,7 @@ partial class ExpressionFinder {
if (la == null) { currentState = 7; break; }
if (la.kind == 40) {
stateStack.Push(7);
- goto case 378;
+ goto case 380;
} else {
goto case 8;
}
@@ -1545,14 +1547,14 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 84 || la.kind == 155 || la.kind == 209) {
- goto case 485;
+ goto case 487;
} else {
if (la.kind == 103) {
- currentState = 474;
+ currentState = 476;
break;
} else {
if (la.kind == 115) {
- currentState = 464;
+ currentState = 466;
break;
} else {
if (la.kind == 142) {
@@ -1568,12 +1570,12 @@ partial class ExpressionFinder {
}
case 9: {
stateStack.Push(10);
- goto case 167;
+ goto case 169;
}
case 10: {
if (la == null) { currentState = 10; break; }
if (la.kind == 37) {
- currentState = 648;
+ currentState = 650;
break;
} else {
goto case 11;
@@ -1591,7 +1593,7 @@ partial class ExpressionFinder {
if (la == null) { currentState = 13; break; }
if (la.kind == 140) {
PushContext(Context.Type, la, t);
- goto case 642;
+ goto case 644;
} else {
goto case 14;
}
@@ -1651,7 +1653,7 @@ partial class ExpressionFinder {
if (la == null) { currentState = 22; break; }
if (la.kind == 40) {
stateStack.Push(21);
- goto case 378;
+ goto case 380;
} else {
isMissingModifier = true;
goto case 23;
@@ -1660,7 +1662,7 @@ partial class ExpressionFinder {
case 23: {
if (la == null) { currentState = 23; break; }
if (set[122].Get(la.kind)) {
- currentState = 641;
+ currentState = 643;
break;
} else {
isMissingModifier = false;
@@ -1671,19 +1673,19 @@ partial class ExpressionFinder {
if (la == null) { currentState = 24; break; }
if (la.kind == 84 || la.kind == 155 || la.kind == 209) {
stateStack.Push(14);
- goto case 485;
+ goto case 487;
} else {
if (la.kind == 103) {
stateStack.Push(14);
- goto case 473;
+ goto case 475;
} else {
if (la.kind == 115) {
stateStack.Push(14);
- goto case 463;
+ goto case 465;
} else {
if (la.kind == 142) {
stateStack.Push(14);
- goto case 462;
+ goto case 464;
} else {
if (set[12].Get(la.kind)) {
stateStack.Push(14);
@@ -1700,11 +1702,11 @@ partial class ExpressionFinder {
case 25: {
if (la == null) { currentState = 25; break; }
if (la.kind == 119) {
- currentState = 456;
+ currentState = 458;
break;
} else {
if (la.kind == 186) {
- currentState = 448;
+ currentState = 450;
break;
} else {
if (la.kind == 127 || la.kind == 210) {
@@ -1733,7 +1735,7 @@ partial class ExpressionFinder {
case 29: {
if (la == null) { currentState = 29; break; }
if (la.kind == 37) {
- currentState = 424;
+ currentState = 426;
break;
} else {
if (la.kind == 63) {
@@ -1799,7 +1801,7 @@ partial class ExpressionFinder {
}
case 35: {
stateStack.Push(36);
- goto case 74;
+ goto case 76;
}
case 36: {
if (la == null) { currentState = 36; break; }
@@ -1823,7 +1825,7 @@ partial class ExpressionFinder {
case 39: {
if (la == null) { currentState = 39; break; }
if (la.kind == 169) {
- currentState = 422;
+ currentState = 424;
break;
} else {
if (set[20].Get(la.kind)) {
@@ -1861,9 +1863,10 @@ partial class ExpressionFinder {
if (la == null) { currentState = 44; break; }
if (set[22].Get(la.kind)) {
activeArgument = 0;
- goto case 418;
+ goto case 420;
} else {
if (la.kind == 22) {
+ activeArgument = 0;
goto case 45;
} else {
goto case 6;
@@ -1872,43 +1875,53 @@ partial class ExpressionFinder {
}
case 45: {
if (la == null) { currentState = 45; break; }
+ Expect(22, la); // ","
currentState = 46;
break;
}
case 46: {
- nextTokenIsPotentialStartOfExpression = true;
+ activeArgument++;
goto case 47;
}
case 47: {
- if (la == null) { currentState = 47; break; }
+ nextTokenIsPotentialStartOfExpression = true;
+ goto case 48;
+ }
+ case 48: {
+ if (la == null) { currentState = 48; break; }
if (set[22].Get(la.kind)) {
- stateStack.Push(48);
- goto case 49;
+ stateStack.Push(49);
+ goto case 51;
} else {
- goto case 48;
+ goto case 49;
}
}
- case 48: {
- if (la == null) { currentState = 48; break; }
+ case 49: {
+ if (la == null) { currentState = 49; break; }
if (la.kind == 22) {
- goto case 45;
+ currentState = 50;
+ break;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 49: {
- PushContext(Context.Expression, la, t);
- goto case 50;
+ case 50: {
+ activeArgument++;
+ goto case 47;
}
- case 50: {
- stateStack.Push(51);
+ case 51: {
+ PushContext(Context.Expression, la, t);
goto case 52;
}
- case 51: {
- if (la == null) { currentState = 51; break; }
+ case 52: {
+ stateStack.Push(53);
+ goto case 54;
+ }
+ case 53: {
+ if (la == null) { currentState = 53; break; }
if (set[124].Get(la.kind)) {
- currentState = 50;
+ currentState = 52;
break;
} else {
PopContext();
@@ -1916,163 +1929,163 @@ partial class ExpressionFinder {
goto switchlbl;
}
}
- case 52: {
+ case 54: {
PushContext(Context.Expression, la, t);
- goto case 53;
+ goto case 55;
}
- case 53: {
+ case 55: {
nextTokenIsPotentialStartOfExpression = true;
- goto case 54;
+ goto case 56;
}
- case 54: {
- if (la == null) { currentState = 54; break; }
+ case 56: {
+ if (la == null) { currentState = 56; break; }
if (set[125].Get(la.kind)) {
- currentState = 53;
+ currentState = 55;
break;
} else {
if (set[32].Get(la.kind)) {
- stateStack.Push(125);
- goto case 136;
+ stateStack.Push(127);
+ goto case 138;
} else {
if (la.kind == 220) {
- currentState = 122;
+ currentState = 124;
break;
} else {
if (la.kind == 162) {
- stateStack.Push(55);
- goto case 60;
+ stateStack.Push(57);
+ goto case 62;
} else {
if (la.kind == 35) {
- stateStack.Push(55);
- goto case 56;
+ stateStack.Push(57);
+ goto case 58;
} else {
Error(la);
- goto case 55;
+ goto case 57;
}
}
}
}
}
}
- case 55: {
+ case 57: {
PopContext();
currentState = stateStack.Pop();
goto switchlbl;
}
- case 56: {
- if (la == null) { currentState = 56; break; }
+ case 58: {
+ if (la == null) { currentState = 58; break; }
Expect(35, la); // "{"
- currentState = 57;
+ currentState = 59;
break;
}
- case 57: {
- stateStack.Push(58);
- goto case 49;
+ case 59: {
+ stateStack.Push(60);
+ goto case 51;
}
- case 58: {
- if (la == null) { currentState = 58; break; }
+ case 60: {
+ if (la == null) { currentState = 60; break; }
if (la.kind == 22) {
- currentState = 57;
+ currentState = 59;
break;
} else {
- goto case 59;
+ goto case 61;
}
}
- case 59: {
- if (la == null) { currentState = 59; break; }
+ case 61: {
+ if (la == null) { currentState = 61; break; }
Expect(36, la); // "}"
currentState = stateStack.Pop();
break;
}
- case 60: {
- if (la == null) { currentState = 60; break; }
+ case 62: {
+ if (la == null) { currentState = 62; break; }
Expect(162, la); // "New"
- currentState = 61;
+ currentState = 63;
break;
}
- case 61: {
+ case 63: {
PushContext(Context.ObjectCreation, la, t);
- goto case 62;
+ goto case 64;
}
- case 62: {
- if (la == null) { currentState = 62; break; }
+ case 64: {
+ if (la == null) { currentState = 64; break; }
if (set[15].Get(la.kind)) {
- stateStack.Push(119);
+ stateStack.Push(121);
goto case 32;
} else {
- goto case 63;
+ goto case 65;
}
}
- case 63: {
- if (la == null) { currentState = 63; break; }
+ case 65: {
+ if (la == null) { currentState = 65; break; }
if (la.kind == 233) {
- currentState = 66;
+ currentState = 68;
break;
} else {
- goto case 64;
+ goto case 66;
}
}
- case 64: {
+ case 66: {
Error(la);
- goto case 65;
+ goto case 67;
}
- case 65: {
+ case 67: {
PopContext();
currentState = stateStack.Pop();
goto switchlbl;
}
- case 66: {
- stateStack.Push(65);
- goto case 67;
- }
- case 67: {
- if (la == null) { currentState = 67; break; }
- Expect(35, la); // "{"
- currentState = 68;
- break;
- }
case 68: {
- if (la == null) { currentState = 68; break; }
- if (la.kind == 147) {
- currentState = 69;
- break;
- } else {
- goto case 69;
- }
+ stateStack.Push(67);
+ goto case 69;
}
case 69: {
if (la == null) { currentState = 69; break; }
- Expect(26, la); // "."
+ Expect(35, la); // "{"
currentState = 70;
break;
}
case 70: {
- stateStack.Push(71);
- goto case 74;
+ if (la == null) { currentState = 70; break; }
+ if (la.kind == 147) {
+ currentState = 71;
+ break;
+ } else {
+ goto case 71;
+ }
}
case 71: {
if (la == null) { currentState = 71; break; }
- Expect(20, la); // "="
+ Expect(26, la); // "."
currentState = 72;
break;
}
case 72: {
stateStack.Push(73);
- goto case 49;
+ goto case 76;
}
case 73: {
if (la == null) { currentState = 73; break; }
+ Expect(20, la); // "="
+ currentState = 74;
+ break;
+ }
+ case 74: {
+ stateStack.Push(75);
+ goto case 51;
+ }
+ case 75: {
+ if (la == null) { currentState = 75; break; }
if (la.kind == 22) {
- currentState = 68;
+ currentState = 70;
break;
} else {
- goto case 59;
+ goto case 61;
}
}
- case 74: {
- if (la == null) { currentState = 74; break; }
+ case 76: {
+ if (la == null) { currentState = 76; break; }
if (la.kind == 2) {
- goto case 118;
+ goto case 120;
} else {
if (la.kind == 56) {
currentState = stateStack.Pop();
@@ -2083,7 +2096,7 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 58) {
- goto case 117;
+ goto case 119;
} else {
if (la.kind == 59) {
currentState = stateStack.Pop();
@@ -2098,23 +2111,23 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 62) {
- goto case 116;
+ goto case 118;
} else {
if (la.kind == 63) {
currentState = stateStack.Pop();
break;
} else {
if (la.kind == 64) {
- goto case 115;
+ goto case 117;
} else {
if (la.kind == 65) {
- goto case 114;
+ goto case 116;
} else {
if (la.kind == 66) {
- goto case 113;
+ goto case 115;
} else {
if (la.kind == 67) {
- goto case 112;
+ goto case 114;
} else {
if (la.kind == 68) {
currentState = stateStack.Pop();
@@ -2125,7 +2138,7 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 70) {
- goto case 111;
+ goto case 113;
} else {
if (la.kind == 71) {
currentState = stateStack.Pop();
@@ -2180,7 +2193,7 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 84) {
- goto case 110;
+ goto case 112;
} else {
if (la.kind == 85) {
currentState = stateStack.Pop();
@@ -2191,7 +2204,7 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 87) {
- goto case 109;
+ goto case 111;
} else {
if (la.kind == 88) {
currentState = stateStack.Pop();
@@ -2234,7 +2247,7 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 98) {
- goto case 108;
+ goto case 110;
} else {
if (la.kind == 99) {
currentState = stateStack.Pop();
@@ -2257,7 +2270,7 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 104) {
- goto case 107;
+ goto case 109;
} else {
if (la.kind == 105) {
currentState = stateStack.Pop();
@@ -2268,10 +2281,10 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 107) {
- goto case 106;
+ goto case 108;
} else {
if (la.kind == 108) {
- goto case 105;
+ goto case 107;
} else {
if (la.kind == 109) {
currentState = stateStack.Pop();
@@ -2302,7 +2315,7 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 116) {
- goto case 104;
+ goto case 106;
} else {
if (la.kind == 117) {
currentState = stateStack.Pop();
@@ -2321,7 +2334,7 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 121) {
- goto case 103;
+ goto case 105;
} else {
if (la.kind == 122) {
currentState = stateStack.Pop();
@@ -2332,17 +2345,17 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 124) {
- goto case 102;
+ goto case 104;
} else {
if (la.kind == 125) {
currentState = stateStack.Pop();
break;
} else {
if (la.kind == 126) {
- goto case 101;
+ goto case 103;
} else {
if (la.kind == 127) {
- goto case 100;
+ goto case 102;
} else {
if (la.kind == 128) {
currentState = stateStack.Pop();
@@ -2365,7 +2378,7 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 133) {
- goto case 99;
+ goto case 101;
} else {
if (la.kind == 134) {
currentState = stateStack.Pop();
@@ -2388,7 +2401,7 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 139) {
- goto case 98;
+ goto case 100;
} else {
if (la.kind == 140) {
currentState = stateStack.Pop();
@@ -2403,7 +2416,7 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 143) {
- goto case 97;
+ goto case 99;
} else {
if (la.kind == 144) {
currentState = stateStack.Pop();
@@ -2414,10 +2427,10 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 146) {
- goto case 96;
+ goto case 98;
} else {
if (la.kind == 147) {
- goto case 95;
+ goto case 97;
} else {
if (la.kind == 148) {
currentState = stateStack.Pop();
@@ -2476,10 +2489,10 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 162) {
- goto case 94;
+ goto case 96;
} else {
if (la.kind == 163) {
- goto case 93;
+ goto case 95;
} else {
if (la.kind == 164) {
currentState = stateStack.Pop();
@@ -2506,7 +2519,7 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 170) {
- goto case 92;
+ goto case 94;
} else {
if (la.kind == 171) {
currentState = stateStack.Pop();
@@ -2529,7 +2542,7 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 176) {
- goto case 91;
+ goto case 93;
} else {
if (la.kind == 177) {
currentState = stateStack.Pop();
@@ -2560,14 +2573,14 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 184) {
- goto case 90;
+ goto case 92;
} else {
if (la.kind == 185) {
currentState = stateStack.Pop();
break;
} else {
if (la.kind == 186) {
- goto case 89;
+ goto case 91;
} else {
if (la.kind == 187) {
currentState = stateStack.Pop();
@@ -2610,7 +2623,7 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 197) {
- goto case 88;
+ goto case 90;
} else {
if (la.kind == 198) {
currentState = stateStack.Pop();
@@ -2633,7 +2646,7 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 203) {
- goto case 87;
+ goto case 89;
} else {
if (la.kind == 204) {
currentState = stateStack.Pop();
@@ -2644,7 +2657,7 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 206) {
- goto case 86;
+ goto case 88;
} else {
if (la.kind == 207) {
currentState = stateStack.Pop();
@@ -2655,19 +2668,19 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 209) {
- goto case 85;
+ goto case 87;
} else {
if (la.kind == 210) {
- goto case 84;
+ goto case 86;
} else {
if (la.kind == 211) {
- goto case 83;
+ goto case 85;
} else {
if (la.kind == 212) {
- goto case 82;
+ goto case 84;
} else {
if (la.kind == 213) {
- goto case 81;
+ goto case 83;
} else {
if (la.kind == 214) {
currentState = stateStack.Pop();
@@ -2686,7 +2699,7 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 218) {
- goto case 80;
+ goto case 82;
} else {
if (la.kind == 219) {
currentState = stateStack.Pop();
@@ -2705,10 +2718,10 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 223) {
- goto case 79;
+ goto case 81;
} else {
if (la.kind == 224) {
- goto case 78;
+ goto case 80;
} else {
if (la.kind == 225) {
currentState = stateStack.Pop();
@@ -2731,17 +2744,17 @@ partial class ExpressionFinder {
break;
} else {
if (la.kind == 230) {
- goto case 77;
+ goto case 79;
} else {
if (la.kind == 231) {
- goto case 76;
+ goto case 78;
} else {
if (la.kind == 232) {
currentState = stateStack.Pop();
break;
} else {
if (la.kind == 233) {
- goto case 75;
+ goto case 77;
} else {
if (la.kind == 234) {
currentState = stateStack.Pop();
@@ -2944,16 +2957,6 @@ partial class ExpressionFinder {
}
}
}
- case 75: {
- if (la == null) { currentState = 75; break; }
- currentState = stateStack.Pop();
- break;
- }
- case 76: {
- if (la == null) { currentState = 76; break; }
- currentState = stateStack.Pop();
- break;
- }
case 77: {
if (la == null) { currentState = 77; break; }
currentState = stateStack.Pop();
@@ -3166,22 +3169,32 @@ partial class ExpressionFinder {
}
case 119: {
if (la == null) { currentState = 119; break; }
+ currentState = stateStack.Pop();
+ break;
+ }
+ case 120: {
+ if (la == null) { currentState = 120; break; }
+ currentState = stateStack.Pop();
+ break;
+ }
+ case 121: {
+ if (la == null) { currentState = 121; break; }
if (la.kind == 126 || la.kind == 233) {
if (la.kind == 126) {
- currentState = 120;
+ currentState = 122;
break;
} else {
- goto case 63;
+ goto case 65;
}
} else {
- goto case 65;
+ goto case 67;
}
}
- case 120: {
- if (la == null) { currentState = 120; break; }
+ case 122: {
+ if (la == null) { currentState = 122; break; }
if (la.kind == 35) {
- stateStack.Push(65);
- goto case 56;
+ stateStack.Push(67);
+ goto case 58;
} else {
if (set[27].Get(la.kind)) {
currentState = endOfStatementTerminatorAndBlock; /* leave this block */
@@ -3190,71 +3203,71 @@ partial class ExpressionFinder {
goto switchlbl;
} else {
- goto case 64;
+ goto case 66;
}
}
}
- case 121: {
- if (la == null) { currentState = 121; break; }
- currentState = 65;
- break;
- }
- case 122: {
- stateStack.Push(123);
- goto case 52;
- }
case 123: {
if (la == null) { currentState = 123; break; }
- Expect(144, la); // "Is"
- currentState = 124;
+ currentState = 67;
break;
}
case 124: {
- stateStack.Push(55);
- goto case 32;
+ stateStack.Push(125);
+ goto case 54;
}
case 125: {
if (la == null) { currentState = 125; break; }
+ Expect(144, la); // "Is"
+ currentState = 126;
+ break;
+ }
+ case 126: {
+ stateStack.Push(57);
+ goto case 32;
+ }
+ case 127: {
+ if (la == null) { currentState = 127; break; }
if (set[29].Get(la.kind)) {
- stateStack.Push(125);
- goto case 126;
+ stateStack.Push(127);
+ goto case 128;
} else {
- goto case 55;
+ goto case 57;
}
}
- case 126: {
- if (la == null) { currentState = 126; break; }
+ case 128: {
+ if (la == null) { currentState = 128; break; }
if (la.kind == 37) {
- currentState = 131;
+ currentState = 133;
break;
} else {
if (set[126].Get(la.kind)) {
- currentState = 127;
+ currentState = 129;
break;
} else {
goto case 6;
}
}
}
- case 127: {
+ case 129: {
nextTokenIsStartOfImportsOrAccessExpression = true;
- goto case 128;
+ goto case 130;
}
- case 128: {
- if (la == null) { currentState = 128; break; }
+ case 130: {
+ if (la == null) { currentState = 130; break; }
if (la.kind == 10) {
- currentState = 129;
+ currentState = 131;
break;
} else {
- goto case 129;
+ goto case 131;
}
}
- case 129: {
- stateStack.Push(130);
- goto case 74;
+ case 131: {
+ stateStack.Push(132);
+ goto case 76;
}
- case 130: {
- if (la == null) { currentState = 130; break; }
+ case 132: {
+ if (la == null) { currentState = 132; break; }
if (la.kind == 11) {
currentState = stateStack.Pop();
break;
@@ -3263,106 +3276,106 @@ partial class ExpressionFinder {
goto switchlbl;
}
}
- case 131: {
+ case 133: {
PushContext(Context.Expression, la, t);
nextTokenIsPotentialStartOfExpression = true;
- goto case 132;
+ goto case 134;
}
- case 132: {
- if (la == null) { currentState = 132; break; }
+ case 134: {
+ if (la == null) { currentState = 134; break; }
if (la.kind == 169) {
- currentState = 134;
+ currentState = 136;
break;
} else {
if (set[20].Get(la.kind)) {
if (set[21].Get(la.kind)) {
- stateStack.Push(133);
+ stateStack.Push(135);
goto case 43;
} else {
- goto case 133;
+ goto case 135;
}
} else {
goto case 6;
}
}
}
- case 133: {
+ case 135: {
PopContext();
goto case 40;
}
- case 134: {
- stateStack.Push(135);
+ case 136: {
+ stateStack.Push(137);
goto case 32;
}
- case 135: {
- if (la == null) { currentState = 135; break; }
+ case 137: {
+ if (la == null) { currentState = 137; break; }
if (la.kind == 22) {
- currentState = 134;
+ currentState = 136;
break;
} else {
goto case 40;
}
}
- case 136: {
+ case 138: {
PushContext(Context.Expression, la, t);
nextTokenIsPotentialStartOfExpression = true;
- goto case 137;
+ goto case 139;
}
- case 137: {
- if (la == null) { currentState = 137; break; }
+ case 139: {
+ if (la == null) { currentState = 139; break; }
if (set[127].Get(la.kind)) {
- currentState = 138;
+ currentState = 140;
break;
} else {
if (la.kind == 37) {
- currentState = 417;
+ currentState = 419;
break;
} else {
if (set[128].Get(la.kind)) {
- currentState = 138;
+ currentState = 140;
break;
} else {
if (set[123].Get(la.kind)) {
- currentState = 138;
+ currentState = 140;
break;
} else {
if (set[126].Get(la.kind)) {
- currentState = 413;
+ currentState = 415;
break;
} else {
if (la.kind == 129) {
- currentState = 411;
+ currentState = 413;
break;
} else {
if (la.kind == 237) {
- currentState = 408;
+ currentState = 410;
break;
} else {
if (set[76].Get(la.kind)) {
- stateStack.Push(138);
+ stateStack.Push(140);
nextTokenIsPotentialStartOfExpression = true;
PushContext(Context.Xml, la, t);
- goto case 391;
+ goto case 393;
} else {
if (la.kind == 127 || la.kind == 210) {
- stateStack.Push(138);
- goto case 212;
+ stateStack.Push(140);
+ goto case 214;
} else {
if (la.kind == 58 || la.kind == 126) {
- stateStack.Push(138);
+ stateStack.Push(140);
PushContext(Context.Query, la, t);
- goto case 152;
+ goto case 154;
} else {
if (set[34].Get(la.kind)) {
- stateStack.Push(138);
- goto case 146;
+ stateStack.Push(140);
+ goto case 148;
} else {
if (la.kind == 135) {
- stateStack.Push(138);
- goto case 139;
+ stateStack.Push(140);
+ goto case 141;
} else {
Error(la);
- goto case 138;
+ goto case 140;
}
}
}
@@ -3376,155 +3389,155 @@ partial class ExpressionFinder {
}
}
}
- case 138: {
+ case 140: {
PopContext();
currentState = stateStack.Pop();
goto switchlbl;
}
- case 139: {
- if (la == null) { currentState = 139; break; }
+ case 141: {
+ if (la == null) { currentState = 141; break; }
Expect(135, la); // "If"
- currentState = 140;
- break;
- }
- case 140: {
- if (la == null) { currentState = 140; break; }
- Expect(37, la); // "("
- currentState = 141;
+ currentState = 142;
break;
}
- case 141: {
- stateStack.Push(142);
- goto case 49;
- }
case 142: {
if (la == null) { currentState = 142; break; }
- Expect(22, la); // ","
+ Expect(37, la); // "("
currentState = 143;
break;
}
case 143: {
stateStack.Push(144);
- goto case 49;
+ goto case 51;
}
case 144: {
if (la == null) { currentState = 144; break; }
+ Expect(22, la); // ","
+ currentState = 145;
+ break;
+ }
+ case 145: {
+ stateStack.Push(146);
+ goto case 51;
+ }
+ case 146: {
+ if (la == null) { currentState = 146; break; }
if (la.kind == 22) {
- currentState = 145;
+ currentState = 147;
break;
} else {
goto case 40;
}
}
- case 145: {
+ case 147: {
stateStack.Push(40);
- goto case 49;
+ goto case 51;
}
- case 146: {
- if (la == null) { currentState = 146; break; }
+ case 148: {
+ if (la == null) { currentState = 148; break; }
if (set[129].Get(la.kind)) {
- currentState = 151;
+ currentState = 153;
break;
} else {
if (la.kind == 94 || la.kind == 106 || la.kind == 219) {
- currentState = 147;
+ currentState = 149;
break;
} else {
goto case 6;
}
}
}
- case 147: {
- if (la == null) { currentState = 147; break; }
+ case 149: {
+ if (la == null) { currentState = 149; break; }
Expect(37, la); // "("
- currentState = 148;
+ currentState = 150;
break;
}
- case 148: {
- stateStack.Push(149);
- goto case 49;
+ case 150: {
+ stateStack.Push(151);
+ goto case 51;
}
- case 149: {
- if (la == null) { currentState = 149; break; }
+ case 151: {
+ if (la == null) { currentState = 151; break; }
Expect(22, la); // ","
- currentState = 150;
+ currentState = 152;
break;
}
- case 150: {
+ case 152: {
stateStack.Push(40);
goto case 32;
}
- case 151: {
- if (la == null) { currentState = 151; break; }
+ case 153: {
+ if (la == null) { currentState = 153; break; }
Expect(37, la); // "("
- currentState = 145;
+ currentState = 147;
break;
}
- case 152: {
- if (la == null) { currentState = 152; break; }
+ case 154: {
+ if (la == null) { currentState = 154; break; }
if (la.kind == 126) {
- stateStack.Push(153);
- goto case 211;
+ stateStack.Push(155);
+ goto case 213;
} else {
if (la.kind == 58) {
- stateStack.Push(153);
- goto case 210;
+ stateStack.Push(155);
+ goto case 212;
} else {
Error(la);
- goto case 153;
+ goto case 155;
}
}
}
- case 153: {
- if (la == null) { currentState = 153; break; }
+ case 155: {
+ if (la == null) { currentState = 155; break; }
if (set[35].Get(la.kind)) {
- stateStack.Push(153);
- goto case 154;
+ stateStack.Push(155);
+ goto case 156;
} else {
PopContext();
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 154: {
- if (la == null) { currentState = 154; break; }
+ case 156: {
+ if (la == null) { currentState = 156; break; }
if (la.kind == 126) {
- currentState = 208;
+ currentState = 210;
break;
} else {
if (la.kind == 58) {
- currentState = 204;
+ currentState = 206;
break;
} else {
if (la.kind == 197) {
- currentState = 202;
+ currentState = 204;
break;
} else {
if (la.kind == 107) {
- goto case 106;
+ goto case 108;
} else {
if (la.kind == 230) {
- currentState = 49;
+ currentState = 51;
break;
} else {
if (la.kind == 176) {
- currentState = 198;
+ currentState = 200;
break;
} else {
if (la.kind == 203 || la.kind == 212) {
- currentState = 196;
+ currentState = 198;
break;
} else {
if (la.kind == 148) {
- currentState = 194;
+ currentState = 196;
break;
} else {
if (la.kind == 133) {
- currentState = 168;
+ currentState = 170;
break;
} else {
if (la.kind == 146) {
- currentState = 155;
+ currentState = 157;
break;
} else {
goto case 6;
@@ -3539,107 +3552,107 @@ partial class ExpressionFinder {
}
}
}
- case 155: {
- stateStack.Push(156);
- goto case 161;
- }
- case 156: {
- if (la == null) { currentState = 156; break; }
- Expect(171, la); // "On"
- currentState = 157;
- break;
- }
case 157: {
stateStack.Push(158);
- goto case 49;
+ goto case 163;
}
case 158: {
if (la == null) { currentState = 158; break; }
- Expect(116, la); // "Equals"
+ Expect(171, la); // "On"
currentState = 159;
break;
}
case 159: {
stateStack.Push(160);
- goto case 49;
+ goto case 51;
}
case 160: {
if (la == null) { currentState = 160; break; }
+ Expect(116, la); // "Equals"
+ currentState = 161;
+ break;
+ }
+ case 161: {
+ stateStack.Push(162);
+ goto case 51;
+ }
+ case 162: {
+ if (la == null) { currentState = 162; break; }
if (la.kind == 22) {
- currentState = 157;
+ currentState = 159;
break;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 161: {
+ case 163: {
PushContext(Context.Identifier, la, t);
SetIdentifierExpected(la);
- stateStack.Push(162);
- goto case 167;
+ stateStack.Push(164);
+ goto case 169;
}
- case 162: {
+ case 164: {
PopContext();
- goto case 163;
+ goto case 165;
}
- case 163: {
- if (la == null) { currentState = 163; break; }
+ case 165: {
+ if (la == null) { currentState = 165; break; }
if (la.kind == 63) {
- currentState = 165;
+ currentState = 167;
break;
} else {
- goto case 164;
+ goto case 166;
}
}
- case 164: {
- if (la == null) { currentState = 164; break; }
+ case 166: {
+ if (la == null) { currentState = 166; break; }
Expect(138, la); // "In"
- currentState = 49;
+ currentState = 51;
break;
}
- case 165: {
+ case 167: {
PushContext(Context.Type, la, t);
- stateStack.Push(166);
+ stateStack.Push(168);
goto case 32;
}
- case 166: {
+ case 168: {
PopContext();
- goto case 164;
+ goto case 166;
}
- case 167: {
- if (la == null) { currentState = 167; break; }
+ case 169: {
+ if (la == null) { currentState = 169; break; }
if (set[114].Get(la.kind)) {
currentState = stateStack.Pop();
break;
} else {
if (la.kind == 98) {
- goto case 108;
+ goto case 110;
} else {
goto case 6;
}
}
}
- case 168: {
+ case 170: {
SetIdentifierExpected(la);
nextTokenIsPotentialStartOfExpression = true;
- goto case 169;
+ goto case 171;
}
- case 169: {
- if (la == null) { currentState = 169; break; }
+ case 171: {
+ if (la == null) { currentState = 171; break; }
if (la.kind == 146) {
- goto case 186;
+ goto case 188;
} else {
if (set[37].Get(la.kind)) {
if (la.kind == 70) {
- currentState = 171;
+ currentState = 173;
break;
} else {
if (set[37].Get(la.kind)) {
- goto case 184;
+ goto case 186;
} else {
Error(la);
- goto case 170;
+ goto case 172;
}
}
} else {
@@ -3647,69 +3660,69 @@ partial class ExpressionFinder {
}
}
}
- case 170: {
- if (la == null) { currentState = 170; break; }
+ case 172: {
+ if (la == null) { currentState = 172; break; }
Expect(70, la); // "By"
- currentState = 171;
+ currentState = 173;
break;
}
- case 171: {
- stateStack.Push(172);
- goto case 175;
+ case 173: {
+ stateStack.Push(174);
+ goto case 177;
}
- case 172: {
- if (la == null) { currentState = 172; break; }
+ case 174: {
+ if (la == null) { currentState = 174; break; }
if (la.kind == 22) {
- currentState = 171;
+ currentState = 173;
break;
} else {
Expect(143, la); // "Into"
- currentState = 173;
+ currentState = 175;
break;
}
}
- case 173: {
- stateStack.Push(174);
- goto case 175;
+ case 175: {
+ stateStack.Push(176);
+ goto case 177;
}
- case 174: {
- if (la == null) { currentState = 174; break; }
+ case 176: {
+ if (la == null) { currentState = 176; break; }
if (la.kind == 22) {
- currentState = 173;
+ currentState = 175;
break;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 175: {
+ case 177: {
SetIdentifierExpected(la);
nextTokenIsPotentialStartOfExpression = true;
- goto case 176;
+ goto case 178;
}
- case 176: {
- if (la == null) { currentState = 176; break; }
+ case 178: {
+ if (la == null) { currentState = 178; break; }
if (set[6].Get(la.kind)) {
PushContext(Context.Identifier, la, t);
SetIdentifierExpected(la);
- stateStack.Push(177);
- goto case 167;
+ stateStack.Push(179);
+ goto case 169;
} else {
- goto case 49;
+ goto case 51;
}
}
- case 177: {
+ case 179: {
PopContext();
- goto case 178;
+ goto case 180;
}
- case 178: {
- if (la == null) { currentState = 178; break; }
+ case 180: {
+ if (la == null) { currentState = 180; break; }
if (la.kind == 63) {
- currentState = 181;
+ currentState = 183;
break;
} else {
if (la.kind == 20) {
- goto case 180;
+ goto case 182;
} else {
if (set[38].Get(la.kind)) {
currentState = endOfStatementTerminatorAndBlock; /* leave this block */
@@ -3719,175 +3732,161 @@ partial class ExpressionFinder {
} else {
Error(la);
- goto case 49;
+ goto case 51;
}
}
}
}
- case 179: {
- if (la == null) { currentState = 179; break; }
- currentState = 49;
+ case 181: {
+ if (la == null) { currentState = 181; break; }
+ currentState = 51;
break;
}
- case 180: {
- if (la == null) { currentState = 180; break; }
- currentState = 49;
+ case 182: {
+ if (la == null) { currentState = 182; break; }
+ currentState = 51;
break;
}
- case 181: {
+ case 183: {
PushContext(Context.Type, la, t);
- stateStack.Push(182);
+ stateStack.Push(184);
goto case 32;
}
- case 182: {
+ case 184: {
PopContext();
- goto case 183;
+ goto case 185;
}
- case 183: {
- if (la == null) { currentState = 183; break; }
+ case 185: {
+ if (la == null) { currentState = 185; break; }
Expect(20, la); // "="
- currentState = 49;
+ currentState = 51;
break;
}
- case 184: {
- stateStack.Push(185);
- goto case 175;
+ case 186: {
+ stateStack.Push(187);
+ goto case 177;
}
- case 185: {
- if (la == null) { currentState = 185; break; }
+ case 187: {
+ if (la == null) { currentState = 187; break; }
if (la.kind == 22) {
- currentState = 184;
+ currentState = 186;
break;
} else {
- goto case 170;
+ goto case 172;
}
}
- case 186: {
- stateStack.Push(187);
- goto case 193;
+ case 188: {
+ stateStack.Push(189);
+ goto case 195;
}
- case 187: {
- if (la == null) { currentState = 187; break; }
+ case 189: {
+ if (la == null) { currentState = 189; break; }
if (la.kind == 133 || la.kind == 146) {
if (la.kind == 133) {
- currentState = 191;
+ currentState = 193;
break;
} else {
if (la.kind == 146) {
- goto case 186;
+ goto case 188;
} else {
Error(la);
- goto case 187;
+ goto case 189;
}
}
} else {
- goto case 188;
+ goto case 190;
}
}
- case 188: {
- if (la == null) { currentState = 188; break; }
+ case 190: {
+ if (la == null) { currentState = 190; break; }
Expect(143, la); // "Into"
- currentState = 189;
+ currentState = 191;
break;
}
- case 189: {
- stateStack.Push(190);
- goto case 175;
+ case 191: {
+ stateStack.Push(192);
+ goto case 177;
}
- case 190: {
- if (la == null) { currentState = 190; break; }
+ case 192: {
+ if (la == null) { currentState = 192; break; }
if (la.kind == 22) {
- currentState = 189;
+ currentState = 191;
break;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 191: {
- stateStack.Push(192);
- goto case 193;
- }
- case 192: {
- stateStack.Push(187);
- goto case 188;
- }
case 193: {
- if (la == null) { currentState = 193; break; }
- Expect(146, la); // "Join"
- currentState = 155;
- break;
+ stateStack.Push(194);
+ goto case 195;
}
case 194: {
- stateStack.Push(195);
- goto case 175;
+ stateStack.Push(189);
+ goto case 190;
}
case 195: {
if (la == null) { currentState = 195; break; }
+ Expect(146, la); // "Join"
+ currentState = 157;
+ break;
+ }
+ case 196: {
+ stateStack.Push(197);
+ goto case 177;
+ }
+ case 197: {
+ if (la == null) { currentState = 197; break; }
if (la.kind == 22) {
- currentState = 194;
+ currentState = 196;
break;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 196: {
+ case 198: {
nextTokenIsPotentialStartOfExpression = true;
- goto case 197;
+ goto case 199;
}
- case 197: {
- if (la == null) { currentState = 197; break; }
+ case 199: {
+ if (la == null) { currentState = 199; break; }
if (la.kind == 231) {
- currentState = 49;
+ currentState = 51;
break;
} else {
- goto case 49;
+ goto case 51;
}
}
- case 198: {
- if (la == null) { currentState = 198; break; }
+ case 200: {
+ if (la == null) { currentState = 200; break; }
Expect(70, la); // "By"
- currentState = 199;
+ currentState = 201;
break;
}
- case 199: {
- stateStack.Push(200);
- goto case 49;
+ case 201: {
+ stateStack.Push(202);
+ goto case 51;
}
- case 200: {
- if (la == null) { currentState = 200; break; }
+ case 202: {
+ if (la == null) { currentState = 202; break; }
if (la.kind == 64) {
- currentState = 201;
+ currentState = 203;
break;
} else {
if (la.kind == 104) {
- currentState = 201;
+ currentState = 203;
break;
} else {
Error(la);
- goto case 201;
+ goto case 203;
}
}
}
- case 201: {
- if (la == null) { currentState = 201; break; }
- if (la.kind == 22) {
- currentState = 199;
- break;
- } else {
- currentState = stateStack.Pop();
- goto switchlbl;
- }
- }
- case 202: {
- stateStack.Push(203);
- goto case 175;
- }
case 203: {
if (la == null) { currentState = 203; break; }
if (la.kind == 22) {
- currentState = 202;
+ currentState = 201;
break;
} else {
currentState = stateStack.Pop();
@@ -3896,36 +3895,36 @@ partial class ExpressionFinder {
}
case 204: {
stateStack.Push(205);
- goto case 161;
+ goto case 177;
}
case 205: {
if (la == null) { currentState = 205; break; }
- if (set[35].Get(la.kind)) {
- stateStack.Push(205);
- goto case 154;
- } else {
- Expect(143, la); // "Into"
- currentState = 206;
+ if (la.kind == 22) {
+ currentState = 204;
break;
+ } else {
+ currentState = stateStack.Pop();
+ goto switchlbl;
}
}
case 206: {
stateStack.Push(207);
- goto case 175;
+ goto case 163;
}
case 207: {
if (la == null) { currentState = 207; break; }
- if (la.kind == 22) {
- currentState = 206;
- break;
+ if (set[35].Get(la.kind)) {
+ stateStack.Push(207);
+ goto case 156;
} else {
- currentState = stateStack.Pop();
- goto switchlbl;
+ Expect(143, la); // "Into"
+ currentState = 208;
+ break;
}
}
case 208: {
stateStack.Push(209);
- goto case 161;
+ goto case 177;
}
case 209: {
if (la == null) { currentState = 209; break; }
@@ -3938,140 +3937,154 @@ partial class ExpressionFinder {
}
}
case 210: {
- if (la == null) { currentState = 210; break; }
- Expect(58, la); // "Aggregate"
- currentState = 204;
- break;
+ stateStack.Push(211);
+ goto case 163;
}
case 211: {
if (la == null) { currentState = 211; break; }
- Expect(126, la); // "From"
- currentState = 208;
- break;
+ if (la.kind == 22) {
+ currentState = 210;
+ break;
+ } else {
+ currentState = stateStack.Pop();
+ goto switchlbl;
+ }
}
case 212: {
if (la == null) { currentState = 212; break; }
+ Expect(58, la); // "Aggregate"
+ currentState = 206;
+ break;
+ }
+ case 213: {
+ if (la == null) { currentState = 213; break; }
+ Expect(126, la); // "From"
+ currentState = 210;
+ break;
+ }
+ case 214: {
+ if (la == null) { currentState = 214; break; }
if (la.kind == 210) {
- currentState = 383;
+ currentState = 385;
break;
} else {
if (la.kind == 127) {
- currentState = 213;
+ currentState = 215;
break;
} else {
goto case 6;
}
}
}
- case 213: {
- if (la == null) { currentState = 213; break; }
+ case 215: {
+ if (la == null) { currentState = 215; break; }
Expect(37, la); // "("
- currentState = 214;
+ currentState = 216;
break;
}
- case 214: {
+ case 216: {
SetIdentifierExpected(la);
- goto case 215;
+ goto case 217;
}
- case 215: {
- if (la == null) { currentState = 215; break; }
+ case 217: {
+ if (la == null) { currentState = 217; break; }
if (set[72].Get(la.kind)) {
- stateStack.Push(216);
- goto case 365;
+ stateStack.Push(218);
+ goto case 367;
} else {
- goto case 216;
+ goto case 218;
}
}
- case 216: {
- if (la == null) { currentState = 216; break; }
+ case 218: {
+ if (la == null) { currentState = 218; break; }
Expect(38, la); // ")"
- currentState = 217;
+ currentState = 219;
break;
}
- case 217: {
+ case 219: {
nextTokenIsPotentialStartOfExpression = true;
- goto case 218;
+ goto case 220;
}
- case 218: {
- if (la == null) { currentState = 218; break; }
+ case 220: {
+ if (la == null) { currentState = 220; break; }
if (set[22].Get(la.kind)) {
- goto case 49;
+ goto case 51;
} else {
if (la.kind == 1 || la.kind == 21 || la.kind == 63) {
if (la.kind == 63) {
- currentState = 363;
+ currentState = 365;
break;
} else {
- goto case 219;
+ goto case 221;
}
} else {
goto case 6;
}
}
}
- case 219: {
- stateStack.Push(220);
- goto case 222;
+ case 221: {
+ stateStack.Push(222);
+ goto case 224;
}
- case 220: {
- if (la == null) { currentState = 220; break; }
+ case 222: {
+ if (la == null) { currentState = 222; break; }
Expect(113, la); // "End"
- currentState = 221;
+ currentState = 223;
break;
}
- case 221: {
- if (la == null) { currentState = 221; break; }
+ case 223: {
+ if (la == null) { currentState = 223; break; }
Expect(127, la); // "Function"
currentState = stateStack.Pop();
break;
}
- case 222: {
+ case 224: {
PushContext(Context.Body, la, t);
- goto case 223;
+ goto case 225;
}
- case 223: {
- stateStack.Push(224);
+ case 225: {
+ stateStack.Push(226);
goto case 18;
}
- case 224: {
+ case 226: {
nextTokenIsPotentialStartOfExpression = true;
- goto case 225;
+ goto case 227;
}
- case 225: {
- if (la == null) { currentState = 225; break; }
+ case 227: {
+ if (la == null) { currentState = 227; break; }
if (set[130].Get(la.kind)) {
if (set[64].Get(la.kind)) {
if (set[46].Get(la.kind)) {
- stateStack.Push(223);
- goto case 230;
+ stateStack.Push(225);
+ goto case 232;
} else {
- goto case 223;
+ goto case 225;
}
} else {
if (la.kind == 113) {
- currentState = 228;
+ currentState = 230;
break;
} else {
- goto case 227;
+ goto case 229;
}
}
} else {
- goto case 226;
+ goto case 228;
}
}
- case 226: {
+ case 228: {
PopContext();
currentState = stateStack.Pop();
goto switchlbl;
}
- case 227: {
+ case 229: {
Error(la);
- goto case 224;
+ goto case 226;
}
- case 228: {
- if (la == null) { currentState = 228; break; }
+ case 230: {
+ if (la == null) { currentState = 230; break; }
if (la.kind == 1 || la.kind == 21) {
- goto case 223;
+ goto case 225;
} else {
if (set[45].Get(la.kind)) {
currentState = endOfStatementTerminatorAndBlock; /* leave this block */
@@ -4080,68 +4093,68 @@ partial class ExpressionFinder {
goto switchlbl;
} else {
- goto case 227;
+ goto case 229;
}
}
}
- case 229: {
- if (la == null) { currentState = 229; break; }
- currentState = 224;
+ case 231: {
+ if (la == null) { currentState = 231; break; }
+ currentState = 226;
break;
}
- case 230: {
+ case 232: {
nextTokenIsPotentialStartOfExpression = true;
- goto case 231;
+ goto case 233;
}
- case 231: {
- if (la == null) { currentState = 231; break; }
+ case 233: {
+ if (la == null) { currentState = 233; break; }
if (la.kind == 88 || la.kind == 105 || la.kind == 204) {
- currentState = 347;
+ currentState = 349;
break;
} else {
if (la.kind == 211 || la.kind == 233) {
- currentState = 343;
+ currentState = 345;
break;
} else {
if (la.kind == 56 || la.kind == 193) {
- currentState = 341;
+ currentState = 343;
break;
} else {
if (la.kind == 189) {
- currentState = 339;
+ currentState = 341;
break;
} else {
if (la.kind == 135) {
- currentState = 321;
+ currentState = 323;
break;
} else {
if (la.kind == 197) {
- currentState = 306;
+ currentState = 308;
break;
} else {
if (la.kind == 231) {
- currentState = 302;
+ currentState = 304;
break;
} else {
if (la.kind == 108) {
- currentState = 296;
+ currentState = 298;
break;
} else {
if (la.kind == 124) {
- currentState = 269;
+ currentState = 271;
break;
} else {
if (la.kind == 118 || la.kind == 171 || la.kind == 194) {
if (la.kind == 118 || la.kind == 171) {
if (la.kind == 171) {
- currentState = 265;
+ currentState = 267;
break;
} else {
- goto case 265;
+ goto case 267;
}
} else {
if (la.kind == 194) {
- currentState = 263;
+ currentState = 265;
break;
} else {
goto case 6;
@@ -4149,31 +4162,31 @@ partial class ExpressionFinder {
}
} else {
if (la.kind == 215) {
- currentState = 261;
+ currentState = 263;
break;
} else {
if (la.kind == 218) {
- currentState = 248;
+ currentState = 250;
break;
} else {
if (set[131].Get(la.kind)) {
if (la.kind == 132) {
- currentState = 245;
+ currentState = 247;
break;
} else {
if (la.kind == 120) {
- currentState = 244;
+ currentState = 246;
break;
} else {
if (la.kind == 89) {
- currentState = 243;
+ currentState = 245;
break;
} else {
if (la.kind == 206) {
- goto case 86;
+ goto case 88;
} else {
if (la.kind == 195) {
- currentState = 240;
+ currentState = 242;
break;
} else {
goto case 6;
@@ -4184,23 +4197,23 @@ partial class ExpressionFinder {
}
} else {
if (la.kind == 191) {
- currentState = 238;
+ currentState = 240;
break;
} else {
if (la.kind == 117) {
- currentState = 236;
+ currentState = 238;
break;
} else {
if (la.kind == 226) {
- currentState = 232;
+ currentState = 234;
break;
} else {
if (set[132].Get(la.kind)) {
if (la.kind == 73) {
- currentState = 49;
+ currentState = 51;
break;
} else {
- goto case 49;
+ goto case 51;
}
} else {
goto case 6;
@@ -4222,113 +4235,113 @@ partial class ExpressionFinder {
}
}
}
- case 232: {
- stateStack.Push(233);
- goto case 49;
+ case 234: {
+ stateStack.Push(235);
+ goto case 51;
}
- case 233: {
- stateStack.Push(234);
- goto case 222;
+ case 235: {
+ stateStack.Push(236);
+ goto case 224;
}
- case 234: {
- if (la == null) { currentState = 234; break; }
+ case 236: {
+ if (la == null) { currentState = 236; break; }
Expect(113, la); // "End"
- currentState = 235;
+ currentState = 237;
break;
}
- case 235: {
- if (la == null) { currentState = 235; break; }
+ case 237: {
+ if (la == null) { currentState = 237; break; }
Expect(226, la); // "Using"
currentState = stateStack.Pop();
break;
}
- case 236: {
- stateStack.Push(237);
- goto case 49;
+ case 238: {
+ stateStack.Push(239);
+ goto case 51;
}
- case 237: {
- if (la == null) { currentState = 237; break; }
+ case 239: {
+ if (la == null) { currentState = 239; break; }
if (la.kind == 22) {
- currentState = 236;
+ currentState = 238;
break;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 238: {
+ case 240: {
nextTokenIsPotentialStartOfExpression = true;
- goto case 239;
+ goto case 241;
}
- case 239: {
- if (la == null) { currentState = 239; break; }
+ case 241: {
+ if (la == null) { currentState = 241; break; }
if (la.kind == 184) {
- currentState = 49;
+ currentState = 51;
break;
} else {
- goto case 49;
+ goto case 51;
}
}
- case 240: {
+ case 242: {
PushContext(Context.Expression, la, t);
nextTokenIsPotentialStartOfExpression = true;
- goto case 241;
+ goto case 243;
}
- case 241: {
- if (la == null) { currentState = 241; break; }
+ case 243: {
+ if (la == null) { currentState = 243; break; }
if (set[22].Get(la.kind)) {
- stateStack.Push(242);
- goto case 49;
+ stateStack.Push(244);
+ goto case 51;
} else {
- goto case 242;
+ goto case 244;
}
}
- case 242: {
+ case 244: {
PopContext();
currentState = stateStack.Pop();
goto switchlbl;
}
- case 243: {
- if (la == null) { currentState = 243; break; }
+ case 245: {
+ if (la == null) { currentState = 245; break; }
if (la.kind == 108) {
- goto case 105;
+ goto case 107;
} else {
if (la.kind == 124) {
- goto case 102;
+ goto case 104;
} else {
if (la.kind == 231) {
- goto case 76;
+ goto case 78;
} else {
goto case 6;
}
}
}
}
- case 244: {
- if (la == null) { currentState = 244; break; }
+ case 246: {
+ if (la == null) { currentState = 246; break; }
if (la.kind == 108) {
- goto case 105;
+ goto case 107;
} else {
if (la.kind == 124) {
- goto case 102;
+ goto case 104;
} else {
if (la.kind == 231) {
- goto case 76;
+ goto case 78;
} else {
if (la.kind == 197) {
- goto case 88;
+ goto case 90;
} else {
if (la.kind == 210) {
- goto case 84;
+ goto case 86;
} else {
if (la.kind == 127) {
- goto case 100;
+ goto case 102;
} else {
if (la.kind == 186) {
- goto case 89;
+ goto case 91;
} else {
if (la.kind == 218) {
- goto case 80;
+ goto case 82;
} else {
goto case 6;
}
@@ -4340,166 +4353,166 @@ partial class ExpressionFinder {
}
}
}
- case 245: {
- if (la == null) { currentState = 245; break; }
+ case 247: {
+ if (la == null) { currentState = 247; break; }
if (set[6].Get(la.kind)) {
- goto case 247;
+ goto case 249;
} else {
if (la.kind == 5) {
- goto case 246;
+ goto case 248;
} else {
goto case 6;
}
}
}
- case 246: {
- if (la == null) { currentState = 246; break; }
- currentState = stateStack.Pop();
- break;
- }
- case 247: {
- if (la == null) { currentState = 247; break; }
- currentState = stateStack.Pop();
- break;
- }
case 248: {
- stateStack.Push(249);
- goto case 222;
+ if (la == null) { currentState = 248; break; }
+ currentState = stateStack.Pop();
+ break;
}
case 249: {
if (la == null) { currentState = 249; break; }
+ currentState = stateStack.Pop();
+ break;
+ }
+ case 250: {
+ stateStack.Push(251);
+ goto case 224;
+ }
+ case 251: {
+ if (la == null) { currentState = 251; break; }
if (la.kind == 75) {
- currentState = 253;
+ currentState = 255;
break;
} else {
if (la.kind == 123) {
- currentState = 252;
+ currentState = 254;
break;
} else {
- goto case 250;
+ goto case 252;
}
}
}
- case 250: {
- if (la == null) { currentState = 250; break; }
+ case 252: {
+ if (la == null) { currentState = 252; break; }
Expect(113, la); // "End"
- currentState = 251;
+ currentState = 253;
break;
}
- case 251: {
- if (la == null) { currentState = 251; break; }
+ case 253: {
+ if (la == null) { currentState = 253; break; }
Expect(218, la); // "Try"
currentState = stateStack.Pop();
break;
}
- case 252: {
- stateStack.Push(250);
- goto case 222;
+ case 254: {
+ stateStack.Push(252);
+ goto case 224;
}
- case 253: {
+ case 255: {
SetIdentifierExpected(la);
- goto case 254;
+ goto case 256;
}
- case 254: {
- if (la == null) { currentState = 254; break; }
+ case 256: {
+ if (la == null) { currentState = 256; break; }
if (set[6].Get(la.kind)) {
PushContext(Context.Identifier, la, t);
SetIdentifierExpected(la);
- stateStack.Push(257);
- goto case 167;
+ stateStack.Push(259);
+ goto case 169;
} else {
- goto case 255;
+ goto case 257;
}
}
- case 255: {
- if (la == null) { currentState = 255; break; }
+ case 257: {
+ if (la == null) { currentState = 257; break; }
if (la.kind == 229) {
- currentState = 256;
+ currentState = 258;
break;
} else {
- goto case 248;
+ goto case 250;
}
}
- case 256: {
- stateStack.Push(248);
- goto case 49;
+ case 258: {
+ stateStack.Push(250);
+ goto case 51;
}
- case 257: {
+ case 259: {
PopContext();
- goto case 258;
+ goto case 260;
}
- case 258: {
- if (la == null) { currentState = 258; break; }
+ case 260: {
+ if (la == null) { currentState = 260; break; }
if (la.kind == 63) {
- currentState = 259;
+ currentState = 261;
break;
} else {
- goto case 255;
+ goto case 257;
}
}
- case 259: {
+ case 261: {
PushContext(Context.Type, la, t);
- stateStack.Push(260);
+ stateStack.Push(262);
goto case 32;
}
- case 260: {
+ case 262: {
PopContext();
- goto case 255;
+ goto case 257;
}
- case 261: {
+ case 263: {
nextTokenIsPotentialStartOfExpression = true;
- goto case 262;
+ goto case 264;
}
- case 262: {
- if (la == null) { currentState = 262; break; }
+ case 264: {
+ if (la == null) { currentState = 264; break; }
if (set[22].Get(la.kind)) {
- goto case 49;
+ goto case 51;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 263: {
- if (la == null) { currentState = 263; break; }
+ case 265: {
+ if (la == null) { currentState = 265; break; }
if (la.kind == 163) {
- goto case 93;
+ goto case 95;
} else {
- goto case 264;
+ goto case 266;
}
}
- case 264: {
- if (la == null) { currentState = 264; break; }
+ case 266: {
+ if (la == null) { currentState = 266; break; }
if (la.kind == 5) {
- goto case 246;
+ goto case 248;
} else {
if (set[6].Get(la.kind)) {
- goto case 247;
+ goto case 249;
} else {
goto case 6;
}
}
}
- case 265: {
- if (la == null) { currentState = 265; break; }
+ case 267: {
+ if (la == null) { currentState = 267; break; }
Expect(118, la); // "Error"
- currentState = 266;
+ currentState = 268;
break;
}
- case 266: {
+ case 268: {
nextTokenIsPotentialStartOfExpression = true;
- goto case 267;
+ goto case 269;
}
- case 267: {
- if (la == null) { currentState = 267; break; }
+ case 269: {
+ if (la == null) { currentState = 269; break; }
if (set[22].Get(la.kind)) {
- goto case 49;
+ goto case 51;
} else {
if (la.kind == 132) {
- currentState = 264;
+ currentState = 266;
break;
} else {
if (la.kind == 194) {
- currentState = 268;
+ currentState = 270;
break;
} else {
goto case 6;
@@ -4507,109 +4520,109 @@ partial class ExpressionFinder {
}
}
}
- case 268: {
- if (la == null) { currentState = 268; break; }
+ case 270: {
+ if (la == null) { currentState = 270; break; }
Expect(163, la); // "Next"
currentState = stateStack.Pop();
break;
}
- case 269: {
+ case 271: {
nextTokenIsPotentialStartOfExpression = true;
SetIdentifierExpected(la);
- goto case 270;
+ goto case 272;
}
- case 270: {
- if (la == null) { currentState = 270; break; }
+ case 272: {
+ if (la == null) { currentState = 272; break; }
if (set[32].Get(la.kind)) {
- stateStack.Push(286);
- goto case 280;
+ stateStack.Push(288);
+ goto case 282;
} else {
if (la.kind == 110) {
- currentState = 271;
+ currentState = 273;
break;
} else {
goto case 6;
}
}
}
- case 271: {
- stateStack.Push(272);
- goto case 280;
- }
- case 272: {
- if (la == null) { currentState = 272; break; }
- Expect(138, la); // "In"
- currentState = 273;
- break;
- }
case 273: {
stateStack.Push(274);
- goto case 49;
+ goto case 282;
}
case 274: {
- stateStack.Push(275);
- goto case 222;
+ if (la == null) { currentState = 274; break; }
+ Expect(138, la); // "In"
+ currentState = 275;
+ break;
}
case 275: {
- if (la == null) { currentState = 275; break; }
- Expect(163, la); // "Next"
- currentState = 276;
- break;
+ stateStack.Push(276);
+ goto case 51;
}
case 276: {
- nextTokenIsPotentialStartOfExpression = true;
- goto case 277;
+ stateStack.Push(277);
+ goto case 224;
}
case 277: {
if (la == null) { currentState = 277; break; }
+ Expect(163, la); // "Next"
+ currentState = 278;
+ break;
+ }
+ case 278: {
+ nextTokenIsPotentialStartOfExpression = true;
+ goto case 279;
+ }
+ case 279: {
+ if (la == null) { currentState = 279; break; }
if (set[22].Get(la.kind)) {
- goto case 278;
+ goto case 280;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 278: {
- stateStack.Push(279);
- goto case 49;
+ case 280: {
+ stateStack.Push(281);
+ goto case 51;
}
- case 279: {
- if (la == null) { currentState = 279; break; }
+ case 281: {
+ if (la == null) { currentState = 281; break; }
if (la.kind == 22) {
- currentState = 278;
+ currentState = 280;
break;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 280: {
+ case 282: {
PushContext(Context.Identifier, la, t);
SetIdentifierExpected(la);
- stateStack.Push(281);
- goto case 136;
+ stateStack.Push(283);
+ goto case 138;
}
- case 281: {
+ case 283: {
PopContext();
- goto case 282;
+ goto case 284;
}
- case 282: {
- if (la == null) { currentState = 282; break; }
+ case 284: {
+ if (la == null) { currentState = 284; break; }
if (la.kind == 33) {
- currentState = 283;
+ currentState = 285;
break;
} else {
- goto case 283;
+ goto case 285;
}
}
- case 283: {
- if (la == null) { currentState = 283; break; }
+ case 285: {
+ if (la == null) { currentState = 285; break; }
if (set[29].Get(la.kind)) {
- stateStack.Push(283);
- goto case 126;
+ stateStack.Push(285);
+ goto case 128;
} else {
if (la.kind == 63) {
- currentState = 284;
+ currentState = 286;
break;
} else {
currentState = stateStack.Pop();
@@ -4617,242 +4630,242 @@ partial class ExpressionFinder {
}
}
}
- case 284: {
+ case 286: {
PushContext(Context.Type, la, t);
- stateStack.Push(285);
+ stateStack.Push(287);
goto case 32;
}
- case 285: {
+ case 287: {
PopContext();
currentState = stateStack.Pop();
goto switchlbl;
}
- case 286: {
- if (la == null) { currentState = 286; break; }
+ case 288: {
+ if (la == null) { currentState = 288; break; }
Expect(20, la); // "="
- currentState = 287;
+ currentState = 289;
break;
}
- case 287: {
- stateStack.Push(288);
- goto case 49;
+ case 289: {
+ stateStack.Push(290);
+ goto case 51;
}
- case 288: {
- if (la == null) { currentState = 288; break; }
+ case 290: {
+ if (la == null) { currentState = 290; break; }
if (la.kind == 205) {
- currentState = 295;
+ currentState = 297;
break;
} else {
- goto case 289;
+ goto case 291;
}
}
- case 289: {
- stateStack.Push(290);
- goto case 222;
+ case 291: {
+ stateStack.Push(292);
+ goto case 224;
}
- case 290: {
- if (la == null) { currentState = 290; break; }
+ case 292: {
+ if (la == null) { currentState = 292; break; }
Expect(163, la); // "Next"
- currentState = 291;
+ currentState = 293;
break;
}
- case 291: {
+ case 293: {
nextTokenIsPotentialStartOfExpression = true;
- goto case 292;
+ goto case 294;
}
- case 292: {
- if (la == null) { currentState = 292; break; }
+ case 294: {
+ if (la == null) { currentState = 294; break; }
if (set[22].Get(la.kind)) {
- goto case 293;
+ goto case 295;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 293: {
- stateStack.Push(294);
- goto case 49;
+ case 295: {
+ stateStack.Push(296);
+ goto case 51;
}
- case 294: {
- if (la == null) { currentState = 294; break; }
+ case 296: {
+ if (la == null) { currentState = 296; break; }
if (la.kind == 22) {
- currentState = 293;
+ currentState = 295;
break;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 295: {
- stateStack.Push(289);
- goto case 49;
+ case 297: {
+ stateStack.Push(291);
+ goto case 51;
}
- case 296: {
- if (la == null) { currentState = 296; break; }
+ case 298: {
+ if (la == null) { currentState = 298; break; }
if (la.kind == 224 || la.kind == 231) {
- currentState = 299;
+ currentState = 301;
break;
} else {
if (la.kind == 1 || la.kind == 21) {
- stateStack.Push(297);
- goto case 222;
+ stateStack.Push(299);
+ goto case 224;
} else {
goto case 6;
}
}
}
- case 297: {
- if (la == null) { currentState = 297; break; }
+ case 299: {
+ if (la == null) { currentState = 299; break; }
Expect(152, la); // "Loop"
- currentState = 298;
+ currentState = 300;
break;
}
- case 298: {
- if (la == null) { currentState = 298; break; }
+ case 300: {
+ if (la == null) { currentState = 300; break; }
if (la.kind == 224 || la.kind == 231) {
- currentState = 49;
+ currentState = 51;
break;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 299: {
- stateStack.Push(300);
- goto case 49;
- }
- case 300: {
- stateStack.Push(301);
- goto case 222;
- }
case 301: {
- if (la == null) { currentState = 301; break; }
- Expect(152, la); // "Loop"
- currentState = stateStack.Pop();
- break;
+ stateStack.Push(302);
+ goto case 51;
}
case 302: {
stateStack.Push(303);
- goto case 49;
+ goto case 224;
}
case 303: {
- stateStack.Push(304);
- goto case 222;
+ if (la == null) { currentState = 303; break; }
+ Expect(152, la); // "Loop"
+ currentState = stateStack.Pop();
+ break;
}
case 304: {
- if (la == null) { currentState = 304; break; }
+ stateStack.Push(305);
+ goto case 51;
+ }
+ case 305: {
+ stateStack.Push(306);
+ goto case 224;
+ }
+ case 306: {
+ if (la == null) { currentState = 306; break; }
Expect(113, la); // "End"
- currentState = 305;
+ currentState = 307;
break;
}
- case 305: {
- if (la == null) { currentState = 305; break; }
+ case 307: {
+ if (la == null) { currentState = 307; break; }
Expect(231, la); // "While"
currentState = stateStack.Pop();
break;
}
- case 306: {
+ case 308: {
nextTokenIsPotentialStartOfExpression = true;
- goto case 307;
+ goto case 309;
}
- case 307: {
- if (la == null) { currentState = 307; break; }
+ case 309: {
+ if (la == null) { currentState = 309; break; }
if (la.kind == 74) {
- currentState = 308;
+ currentState = 310;
break;
} else {
- goto case 308;
+ goto case 310;
}
}
- case 308: {
- stateStack.Push(309);
- goto case 49;
+ case 310: {
+ stateStack.Push(311);
+ goto case 51;
}
- case 309: {
- stateStack.Push(310);
+ case 311: {
+ stateStack.Push(312);
goto case 18;
}
- case 310: {
- if (la == null) { currentState = 310; break; }
+ case 312: {
+ if (la == null) { currentState = 312; break; }
if (la.kind == 74) {
- currentState = 312;
+ currentState = 314;
break;
} else {
Expect(113, la); // "End"
- currentState = 311;
+ currentState = 313;
break;
}
}
- case 311: {
- if (la == null) { currentState = 311; break; }
+ case 313: {
+ if (la == null) { currentState = 313; break; }
Expect(197, la); // "Select"
currentState = stateStack.Pop();
break;
}
- case 312: {
+ case 314: {
nextTokenIsPotentialStartOfExpression = true;
- goto case 313;
+ goto case 315;
}
- case 313: {
- if (la == null) { currentState = 313; break; }
+ case 315: {
+ if (la == null) { currentState = 315; break; }
if (la.kind == 111) {
- currentState = 314;
+ currentState = 316;
break;
} else {
if (set[62].Get(la.kind)) {
- goto case 315;
+ goto case 317;
} else {
Error(la);
- goto case 314;
+ goto case 316;
}
}
}
- case 314: {
- stateStack.Push(310);
- goto case 222;
+ case 316: {
+ stateStack.Push(312);
+ goto case 224;
}
- case 315: {
+ case 317: {
nextTokenIsPotentialStartOfExpression = true;
- goto case 316;
+ goto case 318;
}
- case 316: {
- if (la == null) { currentState = 316; break; }
+ case 318: {
+ if (la == null) { currentState = 318; break; }
if (set[133].Get(la.kind)) {
if (la.kind == 144) {
- currentState = 318;
+ currentState = 320;
break;
} else {
- goto case 318;
+ goto case 320;
}
} else {
if (set[22].Get(la.kind)) {
- stateStack.Push(317);
- goto case 49;
+ stateStack.Push(319);
+ goto case 51;
} else {
Error(la);
- goto case 317;
+ goto case 319;
}
}
}
- case 317: {
- if (la == null) { currentState = 317; break; }
+ case 319: {
+ if (la == null) { currentState = 319; break; }
if (la.kind == 22) {
- currentState = 315;
+ currentState = 317;
break;
} else {
- goto case 314;
+ goto case 316;
}
}
- case 318: {
- stateStack.Push(319);
- goto case 320;
+ case 320: {
+ stateStack.Push(321);
+ goto case 322;
}
- case 319: {
- stateStack.Push(317);
- goto case 52;
+ case 321: {
+ stateStack.Push(319);
+ goto case 54;
}
- case 320: {
- if (la == null) { currentState = 320; break; }
+ case 322: {
+ if (la == null) { currentState = 322; break; }
if (la.kind == 20) {
currentState = stateStack.Pop();
break;
@@ -4885,104 +4898,104 @@ partial class ExpressionFinder {
}
}
}
- case 321: {
- stateStack.Push(322);
- goto case 49;
+ case 323: {
+ stateStack.Push(324);
+ goto case 51;
}
- case 322: {
- if (la == null) { currentState = 322; break; }
+ case 324: {
+ if (la == null) { currentState = 324; break; }
if (la.kind == 214) {
- currentState = 330;
+ currentState = 332;
break;
} else {
- goto case 323;
+ goto case 325;
}
}
- case 323: {
- if (la == null) { currentState = 323; break; }
+ case 325: {
+ if (la == null) { currentState = 325; break; }
if (la.kind == 1 || la.kind == 21) {
- goto case 324;
+ goto case 326;
} else {
goto case 6;
}
}
- case 324: {
- stateStack.Push(325);
- goto case 222;
+ case 326: {
+ stateStack.Push(327);
+ goto case 224;
}
- case 325: {
- if (la == null) { currentState = 325; break; }
+ case 327: {
+ if (la == null) { currentState = 327; break; }
if (la.kind == 111 || la.kind == 112) {
if (la.kind == 111) {
- currentState = 329;
+ currentState = 331;
break;
} else {
if (la.kind == 112) {
- currentState = 327;
+ currentState = 329;
break;
} else {
Error(la);
- goto case 324;
+ goto case 326;
}
}
} else {
Expect(113, la); // "End"
- currentState = 326;
+ currentState = 328;
break;
}
}
- case 326: {
- if (la == null) { currentState = 326; break; }
+ case 328: {
+ if (la == null) { currentState = 328; break; }
Expect(135, la); // "If"
currentState = stateStack.Pop();
break;
}
- case 327: {
- stateStack.Push(328);
- goto case 49;
+ case 329: {
+ stateStack.Push(330);
+ goto case 51;
}
- case 328: {
- if (la == null) { currentState = 328; break; }
+ case 330: {
+ if (la == null) { currentState = 330; break; }
if (la.kind == 214) {
- currentState = 324;
+ currentState = 326;
break;
} else {
- goto case 324;
+ goto case 326;
}
}
- case 329: {
- if (la == null) { currentState = 329; break; }
+ case 331: {
+ if (la == null) { currentState = 331; break; }
if (la.kind == 135) {
- currentState = 327;
+ currentState = 329;
break;
} else {
- goto case 324;
+ goto case 326;
}
}
- case 330: {
+ case 332: {
nextTokenIsPotentialStartOfExpression = true;
- goto case 331;
+ goto case 333;
}
- case 331: {
- if (la == null) { currentState = 331; break; }
+ case 333: {
+ if (la == null) { currentState = 333; break; }
if (set[46].Get(la.kind)) {
- goto case 332;
+ goto case 334;
} else {
- goto case 323;
+ goto case 325;
}
}
- case 332: {
- stateStack.Push(333);
- goto case 230;
- }
- case 333: {
- if (la == null) { currentState = 333; break; }
+ case 334: {
+ stateStack.Push(335);
+ goto case 232;
+ }
+ case 335: {
+ if (la == null) { currentState = 335; break; }
if (la.kind == 21) {
- currentState = 337;
+ currentState = 339;
break;
} else {
if (la.kind == 111) {
- currentState = 334;
+ currentState = 336;
break;
} else {
currentState = stateStack.Pop();
@@ -4990,47 +5003,47 @@ partial class ExpressionFinder {
}
}
}
- case 334: {
+ case 336: {
nextTokenIsPotentialStartOfExpression = true;
- goto case 335;
+ goto case 337;
}
- case 335: {
- if (la == null) { currentState = 335; break; }
+ case 337: {
+ if (la == null) { currentState = 337; break; }
if (set[46].Get(la.kind)) {
- stateStack.Push(336);
- goto case 230;
+ stateStack.Push(338);
+ goto case 232;
} else {
- goto case 336;
+ goto case 338;
}
}
- case 336: {
- if (la == null) { currentState = 336; break; }
+ case 338: {
+ if (la == null) { currentState = 338; break; }
if (la.kind == 21) {
- currentState = 334;
+ currentState = 336;
break;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 337: {
+ case 339: {
nextTokenIsPotentialStartOfExpression = true;
- goto case 338;
+ goto case 340;
}
- case 338: {
- if (la == null) { currentState = 338; break; }
+ case 340: {
+ if (la == null) { currentState = 340; break; }
if (set[46].Get(la.kind)) {
- goto case 332;
+ goto case 334;
} else {
- goto case 333;
+ goto case 335;
}
}
- case 339: {
- stateStack.Push(340);
- goto case 74;
+ case 341: {
+ stateStack.Push(342);
+ goto case 76;
}
- case 340: {
- if (la == null) { currentState = 340; break; }
+ case 342: {
+ if (la == null) { currentState = 342; break; }
if (la.kind == 37) {
currentState = 41;
break;
@@ -5039,288 +5052,288 @@ partial class ExpressionFinder {
goto switchlbl;
}
}
- case 341: {
- stateStack.Push(342);
- goto case 49;
- }
- case 342: {
- if (la == null) { currentState = 342; break; }
- Expect(22, la); // ","
- currentState = 49;
- break;
- }
case 343: {
stateStack.Push(344);
- goto case 49;
+ goto case 51;
}
case 344: {
- stateStack.Push(345);
- goto case 222;
+ if (la == null) { currentState = 344; break; }
+ Expect(22, la); // ","
+ currentState = 51;
+ break;
}
case 345: {
- if (la == null) { currentState = 345; break; }
+ stateStack.Push(346);
+ goto case 51;
+ }
+ case 346: {
+ stateStack.Push(347);
+ goto case 224;
+ }
+ case 347: {
+ if (la == null) { currentState = 347; break; }
Expect(113, la); // "End"
- currentState = 346;
+ currentState = 348;
break;
}
- case 346: {
- if (la == null) { currentState = 346; break; }
+ case 348: {
+ if (la == null) { currentState = 348; break; }
if (la.kind == 233) {
- goto case 75;
+ goto case 77;
} else {
if (la.kind == 211) {
- goto case 83;
+ goto case 85;
} else {
goto case 6;
}
}
}
- case 347: {
+ case 349: {
PushContext(Context.Identifier, la, t);
SetIdentifierExpected(la);
- stateStack.Push(348);
- goto case 167;
+ stateStack.Push(350);
+ goto case 169;
}
- case 348: {
+ case 350: {
PopContext();
- goto case 349;
+ goto case 351;
}
- case 349: {
- if (la == null) { currentState = 349; break; }
+ case 351: {
+ if (la == null) { currentState = 351; break; }
if (la.kind == 33) {
- currentState = 350;
+ currentState = 352;
break;
} else {
- goto case 350;
+ goto case 352;
}
}
- case 350: {
- if (la == null) { currentState = 350; break; }
+ case 352: {
+ if (la == null) { currentState = 352; break; }
if (la.kind == 37) {
- currentState = 362;
+ currentState = 364;
break;
} else {
- goto case 351;
+ goto case 353;
}
}
- case 351: {
- if (la == null) { currentState = 351; break; }
+ case 353: {
+ if (la == null) { currentState = 353; break; }
if (la.kind == 22) {
- currentState = 356;
+ currentState = 358;
break;
} else {
if (la.kind == 63) {
- currentState = 353;
+ currentState = 355;
break;
} else {
- goto case 352;
+ goto case 354;
}
}
}
- case 352: {
- if (la == null) { currentState = 352; break; }
+ case 354: {
+ if (la == null) { currentState = 354; break; }
if (la.kind == 20) {
- goto case 180;
+ goto case 182;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 353: {
+ case 355: {
PushContext(Context.Type, la, t);
- goto case 354;
+ goto case 356;
}
- case 354: {
- if (la == null) { currentState = 354; break; }
+ case 356: {
+ if (la == null) { currentState = 356; break; }
if (la.kind == 162) {
- stateStack.Push(355);
- goto case 60;
+ stateStack.Push(357);
+ goto case 62;
} else {
if (set[15].Get(la.kind)) {
- stateStack.Push(355);
+ stateStack.Push(357);
goto case 32;
} else {
Error(la);
- goto case 355;
+ goto case 357;
}
}
}
- case 355: {
+ case 357: {
PopContext();
- goto case 352;
+ goto case 354;
}
- case 356: {
+ case 358: {
PushContext(Context.Identifier, la, t);
SetIdentifierExpected(la);
- stateStack.Push(357);
- goto case 167;
+ stateStack.Push(359);
+ goto case 169;
}
- case 357: {
+ case 359: {
PopContext();
- goto case 358;
+ goto case 360;
}
- case 358: {
- if (la == null) { currentState = 358; break; }
+ case 360: {
+ if (la == null) { currentState = 360; break; }
if (la.kind == 33) {
- currentState = 359;
+ currentState = 361;
break;
} else {
- goto case 359;
+ goto case 361;
}
}
- case 359: {
- if (la == null) { currentState = 359; break; }
+ case 361: {
+ if (la == null) { currentState = 361; break; }
if (la.kind == 37) {
- currentState = 360;
+ currentState = 362;
break;
} else {
- goto case 351;
+ goto case 353;
}
}
- case 360: {
- if (la == null) { currentState = 360; break; }
+ case 362: {
+ if (la == null) { currentState = 362; break; }
if (la.kind == 22) {
- currentState = 360;
+ currentState = 362;
break;
} else {
- goto case 361;
+ goto case 363;
}
}
- case 361: {
- if (la == null) { currentState = 361; break; }
+ case 363: {
+ if (la == null) { currentState = 363; break; }
Expect(38, la); // ")"
- currentState = 351;
+ currentState = 353;
break;
}
- case 362: {
- if (la == null) { currentState = 362; break; }
+ case 364: {
+ if (la == null) { currentState = 364; break; }
if (la.kind == 22) {
- currentState = 362;
+ currentState = 364;
break;
} else {
- goto case 361;
+ goto case 363;
}
}
- case 363: {
+ case 365: {
PushContext(Context.Type, la, t);
- stateStack.Push(364);
+ stateStack.Push(366);
goto case 32;
}
- case 364: {
+ case 366: {
PopContext();
- goto case 219;
+ goto case 221;
}
- case 365: {
- stateStack.Push(366);
+ case 367: {
+ stateStack.Push(368);
PushContext(Context.Parameter, la, t);
- goto case 367;
+ goto case 369;
}
- case 366: {
- if (la == null) { currentState = 366; break; }
+ case 368: {
+ if (la == null) { currentState = 368; break; }
if (la.kind == 22) {
- currentState = 365;
+ currentState = 367;
break;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 367: {
+ case 369: {
SetIdentifierExpected(la);
- goto case 368;
+ goto case 370;
}
- case 368: {
- if (la == null) { currentState = 368; break; }
+ case 370: {
+ if (la == null) { currentState = 370; break; }
if (la.kind == 40) {
- stateStack.Push(367);
- goto case 378;
+ stateStack.Push(369);
+ goto case 380;
} else {
- goto case 369;
+ goto case 371;
}
}
- case 369: {
+ case 371: {
SetIdentifierExpected(la);
- goto case 370;
+ goto case 372;
}
- case 370: {
- if (la == null) { currentState = 370; break; }
+ case 372: {
+ if (la == null) { currentState = 372; break; }
if (set[134].Get(la.kind)) {
- currentState = 369;
+ currentState = 371;
break;
} else {
PushContext(Context.Identifier, la, t);
SetIdentifierExpected(la);
- stateStack.Push(371);
- goto case 167;
+ stateStack.Push(373);
+ goto case 169;
}
}
- case 371: {
+ case 373: {
PopContext();
- goto case 372;
+ goto case 374;
}
- case 372: {
- if (la == null) { currentState = 372; break; }
+ case 374: {
+ if (la == null) { currentState = 374; break; }
if (la.kind == 63) {
- currentState = 376;
+ currentState = 378;
break;
} else {
- goto case 373;
+ goto case 375;
}
}
- case 373: {
- if (la == null) { currentState = 373; break; }
+ case 375: {
+ if (la == null) { currentState = 375; break; }
if (la.kind == 20) {
- currentState = 375;
+ currentState = 377;
break;
} else {
- goto case 374;
+ goto case 376;
}
}
- case 374: {
+ case 376: {
PopContext();
currentState = stateStack.Pop();
goto switchlbl;
}
- case 375: {
- stateStack.Push(374);
- goto case 49;
+ case 377: {
+ stateStack.Push(376);
+ goto case 51;
}
- case 376: {
+ case 378: {
PushContext(Context.Type, la, t);
- stateStack.Push(377);
+ stateStack.Push(379);
goto case 32;
}
- case 377: {
+ case 379: {
PopContext();
- goto case 373;
+ goto case 375;
}
- case 378: {
- if (la == null) { currentState = 378; break; }
+ case 380: {
+ if (la == null) { currentState = 380; break; }
Expect(40, la); // "<"
- currentState = 379;
+ currentState = 381;
break;
}
- case 379: {
+ case 381: {
PushContext(Context.Attribute, la, t);
- goto case 380;
+ goto case 382;
}
- case 380: {
- if (la == null) { currentState = 380; break; }
+ case 382: {
+ if (la == null) { currentState = 382; break; }
if (set[135].Get(la.kind)) {
- currentState = 380;
+ currentState = 382;
break;
} else {
Expect(39, la); // ">"
- currentState = 381;
+ currentState = 383;
break;
}
}
- case 381: {
+ case 383: {
PopContext();
- goto case 382;
+ goto case 384;
}
- case 382: {
- if (la == null) { currentState = 382; break; }
+ case 384: {
+ if (la == null) { currentState = 384; break; }
if (la.kind == 1) {
goto case 20;
} else {
@@ -5328,505 +5341,505 @@ partial class ExpressionFinder {
goto switchlbl;
}
}
- case 383: {
- if (la == null) { currentState = 383; break; }
+ case 385: {
+ if (la == null) { currentState = 385; break; }
Expect(37, la); // "("
- currentState = 384;
+ currentState = 386;
break;
}
- case 384: {
+ case 386: {
SetIdentifierExpected(la);
- goto case 385;
+ goto case 387;
}
- case 385: {
- if (la == null) { currentState = 385; break; }
+ case 387: {
+ if (la == null) { currentState = 387; break; }
if (set[72].Get(la.kind)) {
- stateStack.Push(386);
- goto case 365;
+ stateStack.Push(388);
+ goto case 367;
} else {
- goto case 386;
+ goto case 388;
}
}
- case 386: {
- if (la == null) { currentState = 386; break; }
+ case 388: {
+ if (la == null) { currentState = 388; break; }
Expect(38, la); // ")"
- currentState = 387;
+ currentState = 389;
break;
}
- case 387: {
+ case 389: {
nextTokenIsPotentialStartOfExpression = true;
- goto case 388;
+ goto case 390;
}
- case 388: {
- if (la == null) { currentState = 388; break; }
+ case 390: {
+ if (la == null) { currentState = 390; break; }
if (set[46].Get(la.kind)) {
- goto case 230;
+ goto case 232;
} else {
if (la.kind == 1 || la.kind == 21) {
- stateStack.Push(389);
- goto case 222;
+ stateStack.Push(391);
+ goto case 224;
} else {
goto case 6;
}
}
}
- case 389: {
- if (la == null) { currentState = 389; break; }
+ case 391: {
+ if (la == null) { currentState = 391; break; }
Expect(113, la); // "End"
- currentState = 390;
+ currentState = 392;
break;
}
- case 390: {
- if (la == null) { currentState = 390; break; }
+ case 392: {
+ if (la == null) { currentState = 392; break; }
Expect(210, la); // "Sub"
currentState = stateStack.Pop();
break;
}
- case 391: {
- if (la == null) { currentState = 391; break; }
+ case 393: {
+ if (la == null) { currentState = 393; break; }
if (la.kind == 17 || la.kind == 18 || la.kind == 19) {
- currentState = 404;
+ currentState = 406;
break;
} else {
if (la.kind == 10) {
- stateStack.Push(393);
- goto case 395;
+ stateStack.Push(395);
+ goto case 397;
} else {
Error(la);
- goto case 392;
+ goto case 394;
}
}
}
- case 392: {
+ case 394: {
PopContext();
currentState = stateStack.Pop();
goto switchlbl;
}
- case 393: {
- if (la == null) { currentState = 393; break; }
+ case 395: {
+ if (la == null) { currentState = 395; break; }
if (la.kind == 17) {
- currentState = 394;
+ currentState = 396;
break;
} else {
- goto case 392;
+ goto case 394;
}
}
- case 394: {
- if (la == null) { currentState = 394; break; }
+ case 396: {
+ if (la == null) { currentState = 396; break; }
if (la.kind == 16) {
- currentState = 393;
+ currentState = 395;
break;
} else {
- goto case 393;
+ goto case 395;
}
}
- case 395: {
+ case 397: {
PushContext(Context.Xml, la, t);
- goto case 396;
+ goto case 398;
}
- case 396: {
- if (la == null) { currentState = 396; break; }
+ case 398: {
+ if (la == null) { currentState = 398; break; }
Expect(10, la); // XmlOpenTag
- currentState = 397;
+ currentState = 399;
break;
}
- case 397: {
- if (la == null) { currentState = 397; break; }
+ case 399: {
+ if (la == null) { currentState = 399; break; }
if (set[136].Get(la.kind)) {
if (set[137].Get(la.kind)) {
- currentState = 397;
+ currentState = 399;
break;
} else {
if (la.kind == 12) {
- stateStack.Push(397);
- goto case 401;
+ stateStack.Push(399);
+ goto case 403;
} else {
Error(la);
- goto case 397;
+ goto case 399;
}
}
} else {
if (la.kind == 14) {
- currentState = 398;
+ currentState = 400;
break;
} else {
if (la.kind == 11) {
- currentState = 399;
+ currentState = 401;
break;
} else {
Error(la);
- goto case 398;
+ goto case 400;
}
}
}
}
- case 398: {
+ case 400: {
PopContext();
currentState = stateStack.Pop();
goto switchlbl;
}
- case 399: {
- if (la == null) { currentState = 399; break; }
+ case 401: {
+ if (la == null) { currentState = 401; break; }
if (set[138].Get(la.kind)) {
if (set[139].Get(la.kind)) {
- currentState = 399;
+ currentState = 401;
break;
} else {
if (la.kind == 12) {
- stateStack.Push(399);
- goto case 401;
+ stateStack.Push(401);
+ goto case 403;
} else {
if (la.kind == 10) {
- stateStack.Push(399);
- goto case 395;
+ stateStack.Push(401);
+ goto case 397;
} else {
Error(la);
- goto case 399;
+ goto case 401;
}
}
}
} else {
Expect(15, la); // XmlOpenEndTag
- currentState = 400;
+ currentState = 402;
break;
}
}
- case 400: {
- if (la == null) { currentState = 400; break; }
+ case 402: {
+ if (la == null) { currentState = 402; break; }
if (set[140].Get(la.kind)) {
if (set[141].Get(la.kind)) {
- currentState = 400;
+ currentState = 402;
break;
} else {
if (la.kind == 12) {
- stateStack.Push(400);
- goto case 401;
+ stateStack.Push(402);
+ goto case 403;
} else {
Error(la);
- goto case 400;
+ goto case 402;
}
}
} else {
Expect(11, la); // XmlCloseTag
- currentState = 398;
+ currentState = 400;
break;
}
}
- case 401: {
- if (la == null) { currentState = 401; break; }
+ case 403: {
+ if (la == null) { currentState = 403; break; }
Expect(12, la); // XmlStartInlineVB
- currentState = 402;
+ currentState = 404;
break;
}
- case 402: {
- stateStack.Push(403);
- goto case 49;
+ case 404: {
+ stateStack.Push(405);
+ goto case 51;
}
- case 403: {
- if (la == null) { currentState = 403; break; }
+ case 405: {
+ if (la == null) { currentState = 405; break; }
Expect(13, la); // XmlEndInlineVB
currentState = stateStack.Pop();
break;
}
- case 404: {
- if (la == null) { currentState = 404; break; }
+ case 406: {
+ if (la == null) { currentState = 406; break; }
if (la.kind == 16) {
- currentState = 405;
+ currentState = 407;
break;
} else {
- goto case 405;
+ goto case 407;
}
}
- case 405: {
- if (la == null) { currentState = 405; break; }
+ case 407: {
+ if (la == null) { currentState = 407; break; }
if (la.kind == 17 || la.kind == 19) {
- currentState = 404;
+ currentState = 406;
break;
} else {
if (la.kind == 10) {
- stateStack.Push(406);
- goto case 395;
+ stateStack.Push(408);
+ goto case 397;
} else {
- goto case 392;
+ goto case 394;
}
}
}
- case 406: {
- if (la == null) { currentState = 406; break; }
+ case 408: {
+ if (la == null) { currentState = 408; break; }
if (la.kind == 17) {
- currentState = 407;
+ currentState = 409;
break;
} else {
- goto case 392;
+ goto case 394;
}
}
- case 407: {
- if (la == null) { currentState = 407; break; }
+ case 409: {
+ if (la == null) { currentState = 409; break; }
if (la.kind == 16) {
- currentState = 406;
+ currentState = 408;
break;
} else {
- goto case 406;
+ goto case 408;
}
}
- case 408: {
- if (la == null) { currentState = 408; break; }
+ case 410: {
+ if (la == null) { currentState = 410; break; }
Expect(37, la); // "("
- currentState = 409;
+ currentState = 411;
break;
}
- case 409: {
+ case 411: {
readXmlIdentifier = true;
- stateStack.Push(410);
- goto case 167;
- }
- case 410: {
- if (la == null) { currentState = 410; break; }
+ stateStack.Push(412);
+ goto case 169;
+ }
+ case 412: {
+ if (la == null) { currentState = 412; break; }
Expect(38, la); // ")"
- currentState = 138;
+ currentState = 140;
break;
}
- case 411: {
- if (la == null) { currentState = 411; break; }
+ case 413: {
+ if (la == null) { currentState = 413; break; }
Expect(37, la); // "("
- currentState = 412;
+ currentState = 414;
break;
}
- case 412: {
- stateStack.Push(410);
+ case 414: {
+ stateStack.Push(412);
goto case 32;
}
- case 413: {
+ case 415: {
nextTokenIsStartOfImportsOrAccessExpression = true; wasQualifierTokenAtStart = true;
- goto case 414;
+ goto case 416;
}
- case 414: {
- if (la == null) { currentState = 414; break; }
+ case 416: {
+ if (la == null) { currentState = 416; break; }
if (la.kind == 10) {
- currentState = 415;
+ currentState = 417;
break;
} else {
- goto case 415;
+ goto case 417;
}
}
- case 415: {
- stateStack.Push(416);
- goto case 74;
+ case 417: {
+ stateStack.Push(418);
+ goto case 76;
}
- case 416: {
- if (la == null) { currentState = 416; break; }
+ case 418: {
+ if (la == null) { currentState = 418; break; }
if (la.kind == 11) {
- currentState = 138;
+ currentState = 140;
break;
} else {
- goto case 138;
+ goto case 140;
}
}
- case 417: {
- stateStack.Push(410);
- goto case 49;
+ case 419: {
+ stateStack.Push(412);
+ goto case 51;
}
- case 418: {
- stateStack.Push(419);
- goto case 49;
+ case 420: {
+ stateStack.Push(421);
+ goto case 51;
}
- case 419: {
- if (la == null) { currentState = 419; break; }
+ case 421: {
+ if (la == null) { currentState = 421; break; }
if (la.kind == 22) {
- currentState = 420;
+ currentState = 422;
break;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 420: {
+ case 422: {
activeArgument++;
nextTokenIsPotentialStartOfExpression = true;
- goto case 421;
+ goto case 423;
}
- case 421: {
- if (la == null) { currentState = 421; break; }
+ case 423: {
+ if (la == null) { currentState = 423; break; }
if (set[22].Get(la.kind)) {
- goto case 418;
+ goto case 420;
} else {
- goto case 419;
+ goto case 421;
}
}
- case 422: {
- if (la == null) { currentState = 422; break; }
+ case 424: {
+ if (la == null) { currentState = 424; break; }
if (set[15].Get(la.kind)) {
- stateStack.Push(423);
+ stateStack.Push(425);
goto case 32;
} else {
- goto case 423;
+ goto case 425;
}
}
- case 423: {
- if (la == null) { currentState = 423; break; }
+ case 425: {
+ if (la == null) { currentState = 425; break; }
if (la.kind == 22) {
- currentState = 422;
+ currentState = 424;
break;
} else {
goto case 40;
}
}
- case 424: {
+ case 426: {
SetIdentifierExpected(la);
- goto case 425;
+ goto case 427;
}
- case 425: {
- if (la == null) { currentState = 425; break; }
+ case 427: {
+ if (la == null) { currentState = 427; break; }
if (set[142].Get(la.kind)) {
if (la.kind == 169) {
- currentState = 427;
+ currentState = 429;
break;
} else {
if (set[72].Get(la.kind)) {
- stateStack.Push(426);
- goto case 365;
+ stateStack.Push(428);
+ goto case 367;
} else {
Error(la);
- goto case 426;
+ goto case 428;
}
}
} else {
- goto case 426;
+ goto case 428;
}
}
- case 426: {
- if (la == null) { currentState = 426; break; }
+ case 428: {
+ if (la == null) { currentState = 428; break; }
Expect(38, la); // ")"
currentState = 29;
break;
}
- case 427: {
- stateStack.Push(426);
- goto case 428;
+ case 429: {
+ stateStack.Push(428);
+ goto case 430;
}
- case 428: {
+ case 430: {
SetIdentifierExpected(la);
- goto case 429;
+ goto case 431;
}
- case 429: {
- if (la == null) { currentState = 429; break; }
+ case 431: {
+ if (la == null) { currentState = 431; break; }
if (la.kind == 138 || la.kind == 178) {
- currentState = 430;
+ currentState = 432;
break;
} else {
- goto case 430;
+ goto case 432;
}
}
- case 430: {
+ case 432: {
PushContext(Context.Identifier, la, t);
SetIdentifierExpected(la);
- stateStack.Push(431);
- goto case 445;
+ stateStack.Push(433);
+ goto case 447;
}
- case 431: {
+ case 433: {
PopContext();
- goto case 432;
+ goto case 434;
}
- case 432: {
- if (la == null) { currentState = 432; break; }
+ case 434: {
+ if (la == null) { currentState = 434; break; }
if (la.kind == 63) {
- currentState = 446;
+ currentState = 448;
break;
} else {
- goto case 433;
+ goto case 435;
}
}
- case 433: {
- if (la == null) { currentState = 433; break; }
+ case 435: {
+ if (la == null) { currentState = 435; break; }
if (la.kind == 22) {
- currentState = 434;
+ currentState = 436;
break;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 434: {
+ case 436: {
SetIdentifierExpected(la);
- goto case 435;
+ goto case 437;
}
- case 435: {
- if (la == null) { currentState = 435; break; }
+ case 437: {
+ if (la == null) { currentState = 437; break; }
if (la.kind == 138 || la.kind == 178) {
- currentState = 436;
+ currentState = 438;
break;
} else {
- goto case 436;
+ goto case 438;
}
}
- case 436: {
+ case 438: {
PushContext(Context.Identifier, la, t);
SetIdentifierExpected(la);
- stateStack.Push(437);
- goto case 445;
+ stateStack.Push(439);
+ goto case 447;
}
- case 437: {
+ case 439: {
PopContext();
- goto case 438;
+ goto case 440;
}
- case 438: {
- if (la == null) { currentState = 438; break; }
+ case 440: {
+ if (la == null) { currentState = 440; break; }
if (la.kind == 63) {
- currentState = 439;
+ currentState = 441;
break;
} else {
- goto case 433;
+ goto case 435;
}
}
- case 439: {
+ case 441: {
PushContext(Context.Type, la, t);
- stateStack.Push(440);
- goto case 441;
+ stateStack.Push(442);
+ goto case 443;
}
- case 440: {
+ case 442: {
PopContext();
- goto case 433;
+ goto case 435;
}
- case 441: {
- if (la == null) { currentState = 441; break; }
+ case 443: {
+ if (la == null) { currentState = 443; break; }
if (set[87].Get(la.kind)) {
- goto case 444;
+ goto case 446;
} else {
if (la.kind == 35) {
- currentState = 442;
+ currentState = 444;
break;
} else {
goto case 6;
}
}
}
- case 442: {
- stateStack.Push(443);
- goto case 444;
+ case 444: {
+ stateStack.Push(445);
+ goto case 446;
}
- case 443: {
- if (la == null) { currentState = 443; break; }
+ case 445: {
+ if (la == null) { currentState = 445; break; }
if (la.kind == 22) {
- currentState = 442;
+ currentState = 444;
break;
} else {
- goto case 59;
+ goto case 61;
}
}
- case 444: {
- if (la == null) { currentState = 444; break; }
+ case 446: {
+ if (la == null) { currentState = 446; break; }
if (set[15].Get(la.kind)) {
currentState = 33;
break;
} else {
if (la.kind == 162) {
- goto case 94;
+ goto case 96;
} else {
if (la.kind == 84) {
- goto case 110;
+ goto case 112;
} else {
if (la.kind == 209) {
- goto case 85;
+ goto case 87;
} else {
goto case 6;
}
@@ -5834,85 +5847,85 @@ partial class ExpressionFinder {
}
}
}
- case 445: {
- if (la == null) { currentState = 445; break; }
+ case 447: {
+ if (la == null) { currentState = 447; break; }
if (la.kind == 2) {
- goto case 118;
+ goto case 120;
} else {
if (la.kind == 62) {
- goto case 116;
+ goto case 118;
} else {
if (la.kind == 64) {
- goto case 115;
+ goto case 117;
} else {
if (la.kind == 65) {
- goto case 114;
+ goto case 116;
} else {
if (la.kind == 66) {
- goto case 113;
+ goto case 115;
} else {
if (la.kind == 67) {
- goto case 112;
+ goto case 114;
} else {
if (la.kind == 70) {
- goto case 111;
+ goto case 113;
} else {
if (la.kind == 87) {
- goto case 109;
+ goto case 111;
} else {
if (la.kind == 104) {
- goto case 107;
+ goto case 109;
} else {
if (la.kind == 107) {
- goto case 106;
+ goto case 108;
} else {
if (la.kind == 116) {
- goto case 104;
+ goto case 106;
} else {
if (la.kind == 121) {
- goto case 103;
+ goto case 105;
} else {
if (la.kind == 133) {
- goto case 99;
+ goto case 101;
} else {
if (la.kind == 139) {
- goto case 98;
+ goto case 100;
} else {
if (la.kind == 143) {
- goto case 97;
+ goto case 99;
} else {
if (la.kind == 146) {
- goto case 96;
+ goto case 98;
} else {
if (la.kind == 147) {
- goto case 95;
+ goto case 97;
} else {
if (la.kind == 170) {
- goto case 92;
+ goto case 94;
} else {
if (la.kind == 176) {
- goto case 91;
+ goto case 93;
} else {
if (la.kind == 184) {
- goto case 90;
+ goto case 92;
} else {
if (la.kind == 203) {
- goto case 87;
+ goto case 89;
} else {
if (la.kind == 212) {
- goto case 82;
+ goto case 84;
} else {
if (la.kind == 213) {
- goto case 81;
+ goto case 83;
} else {
if (la.kind == 223) {
- goto case 79;
+ goto case 81;
} else {
if (la.kind == 224) {
- goto case 78;
+ goto case 80;
} else {
if (la.kind == 230) {
- goto case 77;
+ goto case 79;
} else {
goto case 6;
}
@@ -5942,327 +5955,313 @@ partial class ExpressionFinder {
}
}
}
- case 446: {
+ case 448: {
PushContext(Context.Type, la, t);
- stateStack.Push(447);
- goto case 441;
+ stateStack.Push(449);
+ goto case 443;
}
- case 447: {
+ case 449: {
PopContext();
- goto case 433;
+ goto case 435;
}
- case 448: {
- stateStack.Push(449);
- goto case 167;
+ case 450: {
+ stateStack.Push(451);
+ goto case 169;
}
- case 449: {
- if (la == null) { currentState = 449; break; }
+ case 451: {
+ if (la == null) { currentState = 451; break; }
if (la.kind == 37) {
- currentState = 453;
+ currentState = 455;
break;
} else {
- goto case 450;
+ goto case 452;
}
}
- case 450: {
- if (la == null) { currentState = 450; break; }
+ case 452: {
+ if (la == null) { currentState = 452; break; }
if (la.kind == 63) {
- currentState = 451;
+ currentState = 453;
break;
} else {
goto case 18;
}
}
- case 451: {
- if (la == null) { currentState = 451; break; }
+ case 453: {
+ if (la == null) { currentState = 453; break; }
if (la.kind == 40) {
- stateStack.Push(451);
- goto case 378;
+ stateStack.Push(453);
+ goto case 380;
} else {
- goto case 452;
+ goto case 454;
}
}
- case 452: {
+ case 454: {
stateStack.Push(18);
goto case 32;
}
- case 453: {
+ case 455: {
SetIdentifierExpected(la);
- goto case 454;
+ goto case 456;
}
- case 454: {
- if (la == null) { currentState = 454; break; }
+ case 456: {
+ if (la == null) { currentState = 456; break; }
if (set[72].Get(la.kind)) {
- stateStack.Push(455);
- goto case 365;
+ stateStack.Push(457);
+ goto case 367;
} else {
- goto case 455;
+ goto case 457;
}
}
- case 455: {
- if (la == null) { currentState = 455; break; }
+ case 457: {
+ if (la == null) { currentState = 457; break; }
Expect(38, la); // ")"
- currentState = 450;
+ currentState = 452;
break;
}
- case 456: {
- stateStack.Push(457);
- goto case 167;
+ case 458: {
+ stateStack.Push(459);
+ goto case 169;
}
- case 457: {
- if (la == null) { currentState = 457; break; }
+ case 459: {
+ if (la == null) { currentState = 459; break; }
if (la.kind == 37 || la.kind == 63) {
if (la.kind == 63) {
- currentState = 452;
+ currentState = 454;
break;
} else {
if (la.kind == 37) {
- currentState = 459;
+ currentState = 461;
break;
} else {
- goto case 458;
+ goto case 460;
}
}
} else {
goto case 18;
}
}
- case 458: {
+ case 460: {
Error(la);
goto case 18;
}
- case 459: {
+ case 461: {
SetIdentifierExpected(la);
- goto case 460;
+ goto case 462;
}
- case 460: {
- if (la == null) { currentState = 460; break; }
+ case 462: {
+ if (la == null) { currentState = 462; break; }
if (set[72].Get(la.kind)) {
- stateStack.Push(461);
- goto case 365;
+ stateStack.Push(463);
+ goto case 367;
} else {
- goto case 461;
+ goto case 463;
}
}
- case 461: {
- if (la == null) { currentState = 461; break; }
+ case 463: {
+ if (la == null) { currentState = 463; break; }
Expect(38, la); // ")"
currentState = 18;
break;
}
- case 462: {
- if (la == null) { currentState = 462; break; }
+ case 464: {
+ if (la == null) { currentState = 464; break; }
Expect(142, la); // "Interface"
currentState = 9;
break;
}
- case 463: {
- if (la == null) { currentState = 463; break; }
+ case 465: {
+ if (la == null) { currentState = 465; break; }
Expect(115, la); // "Enum"
- currentState = 464;
+ currentState = 466;
break;
}
- case 464: {
- stateStack.Push(465);
- goto case 167;
+ case 466: {
+ stateStack.Push(467);
+ goto case 169;
}
- case 465: {
- if (la == null) { currentState = 465; break; }
+ case 467: {
+ if (la == null) { currentState = 467; break; }
if (la.kind == 63) {
- currentState = 472;
+ currentState = 474;
break;
} else {
- goto case 466;
+ goto case 468;
}
}
- case 466: {
- stateStack.Push(467);
+ case 468: {
+ stateStack.Push(469);
goto case 18;
}
- case 467: {
- if (la == null) { currentState = 467; break; }
+ case 469: {
+ if (la == null) { currentState = 469; break; }
if (set[90].Get(la.kind)) {
- goto case 469;
+ goto case 471;
} else {
Expect(113, la); // "End"
- currentState = 468;
+ currentState = 470;
break;
}
}
- case 468: {
- if (la == null) { currentState = 468; break; }
+ case 470: {
+ if (la == null) { currentState = 470; break; }
Expect(115, la); // "Enum"
currentState = 18;
break;
}
- case 469: {
- if (la == null) { currentState = 469; break; }
+ case 471: {
+ if (la == null) { currentState = 471; break; }
if (la.kind == 40) {
- stateStack.Push(469);
- goto case 378;
+ stateStack.Push(471);
+ goto case 380;
} else {
- stateStack.Push(470);
- goto case 167;
+ stateStack.Push(472);
+ goto case 169;
}
}
- case 470: {
- if (la == null) { currentState = 470; break; }
+ case 472: {
+ if (la == null) { currentState = 472; break; }
if (la.kind == 20) {
- currentState = 471;
+ currentState = 473;
break;
} else {
- goto case 466;
+ goto case 468;
}
}
- case 471: {
- stateStack.Push(466);
- goto case 49;
+ case 473: {
+ stateStack.Push(468);
+ goto case 51;
}
- case 472: {
- stateStack.Push(466);
+ case 474: {
+ stateStack.Push(468);
goto case 32;
}
- case 473: {
- if (la == null) { currentState = 473; break; }
+ case 475: {
+ if (la == null) { currentState = 475; break; }
Expect(103, la); // "Delegate"
- currentState = 474;
+ currentState = 476;
break;
}
- case 474: {
- if (la == null) { currentState = 474; break; }
+ case 476: {
+ if (la == null) { currentState = 476; break; }
if (la.kind == 210) {
- currentState = 475;
+ currentState = 477;
break;
} else {
if (la.kind == 127) {
- currentState = 475;
+ currentState = 477;
break;
} else {
Error(la);
- goto case 475;
+ goto case 477;
}
}
}
- case 475: {
+ case 477: {
PushContext(Context.Identifier, la, t);
SetIdentifierExpected(la);
- goto case 476;
+ goto case 478;
}
- case 476: {
- if (la == null) { currentState = 476; break; }
- currentState = 477;
+ case 478: {
+ if (la == null) { currentState = 478; break; }
+ currentState = 479;
break;
}
- case 477: {
+ case 479: {
PopContext();
- goto case 478;
+ goto case 480;
}
- case 478: {
- if (la == null) { currentState = 478; break; }
+ case 480: {
+ if (la == null) { currentState = 480; break; }
if (la.kind == 37) {
- currentState = 482;
+ currentState = 484;
break;
} else {
- goto case 479;
+ goto case 481;
}
}
- case 479: {
- if (la == null) { currentState = 479; break; }
+ case 481: {
+ if (la == null) { currentState = 481; break; }
if (la.kind == 63) {
- currentState = 480;
+ currentState = 482;
break;
} else {
goto case 18;
}
}
- case 480: {
+ case 482: {
PushContext(Context.Type, la, t);
- stateStack.Push(481);
+ stateStack.Push(483);
goto case 32;
}
- case 481: {
+ case 483: {
PopContext();
goto case 18;
}
- case 482: {
+ case 484: {
SetIdentifierExpected(la);
- goto case 483;
+ goto case 485;
}
- case 483: {
- if (la == null) { currentState = 483; break; }
+ case 485: {
+ if (la == null) { currentState = 485; break; }
if (set[72].Get(la.kind)) {
- stateStack.Push(484);
- goto case 365;
+ stateStack.Push(486);
+ goto case 367;
} else {
- goto case 484;
+ goto case 486;
}
}
- case 484: {
- if (la == null) { currentState = 484; break; }
+ case 486: {
+ if (la == null) { currentState = 486; break; }
Expect(38, la); // ")"
- currentState = 479;
+ currentState = 481;
break;
}
- case 485: {
+ case 487: {
PushContext(Context.TypeDeclaration, la, t);
- goto case 486;
+ goto case 488;
}
- case 486: {
- if (la == null) { currentState = 486; break; }
+ case 488: {
+ if (la == null) { currentState = 488; break; }
if (la.kind == 155) {
- currentState = 487;
+ currentState = 489;
break;
} else {
if (la.kind == 84) {
- currentState = 487;
+ currentState = 489;
break;
} else {
if (la.kind == 209) {
- currentState = 487;
+ currentState = 489;
break;
} else {
Error(la);
- goto case 487;
+ goto case 489;
}
}
}
}
- case 487: {
+ case 489: {
PushContext(Context.Identifier, la, t);
SetIdentifierExpected(la);
- stateStack.Push(488);
- goto case 167;
+ stateStack.Push(490);
+ goto case 169;
}
- case 488: {
+ case 490: {
PopContext();
- goto case 489;
+ goto case 491;
}
- case 489: {
- if (la == null) { currentState = 489; break; }
+ case 491: {
+ if (la == null) { currentState = 491; break; }
if (la.kind == 37) {
- currentState = 638;
+ currentState = 640;
break;
} else {
- goto case 490;
+ goto case 492;
}
}
- case 490: {
- stateStack.Push(491);
- goto case 18;
- }
- case 491: {
- SetIdentifierExpected(la);
- isMissingModifier = true;
- goto case 492;
- }
case 492: {
- if (la == null) { currentState = 492; break; }
- if (la.kind == 140) {
- isMissingModifier = false;
- goto case 635;
- } else {
- goto case 493;
- }
+ stateStack.Push(493);
+ goto case 18;
}
case 493: {
SetIdentifierExpected(la);
@@ -6271,9 +6270,9 @@ partial class ExpressionFinder {
}
case 494: {
if (la == null) { currentState = 494; break; }
- if (la.kind == 136) {
+ if (la.kind == 140) {
isMissingModifier = false;
- goto case 629;
+ goto case 637;
} else {
goto case 495;
}
@@ -6285,142 +6284,156 @@ partial class ExpressionFinder {
}
case 496: {
if (la == null) { currentState = 496; break; }
- if (set[95].Get(la.kind)) {
- goto case 501;
- } else {
+ if (la.kind == 136) {
isMissingModifier = false;
+ goto case 631;
+ } else {
goto case 497;
}
}
case 497: {
- if (la == null) { currentState = 497; break; }
- Expect(113, la); // "End"
- currentState = 498;
- break;
+ SetIdentifierExpected(la);
+ isMissingModifier = true;
+ goto case 498;
}
case 498: {
if (la == null) { currentState = 498; break; }
+ if (set[95].Get(la.kind)) {
+ goto case 503;
+ } else {
+ isMissingModifier = false;
+ goto case 499;
+ }
+ }
+ case 499: {
+ if (la == null) { currentState = 499; break; }
+ Expect(113, la); // "End"
+ currentState = 500;
+ break;
+ }
+ case 500: {
+ if (la == null) { currentState = 500; break; }
if (la.kind == 155) {
- currentState = 499;
+ currentState = 501;
break;
} else {
if (la.kind == 84) {
- currentState = 499;
+ currentState = 501;
break;
} else {
if (la.kind == 209) {
- currentState = 499;
+ currentState = 501;
break;
} else {
Error(la);
- goto case 499;
+ goto case 501;
}
}
}
}
- case 499: {
- stateStack.Push(500);
+ case 501: {
+ stateStack.Push(502);
goto case 18;
}
- case 500: {
+ case 502: {
PopContext();
currentState = stateStack.Pop();
goto switchlbl;
}
- case 501: {
+ case 503: {
SetIdentifierExpected(la);
isMissingModifier = true;
- goto case 502;
+ goto case 504;
}
- case 502: {
- if (la == null) { currentState = 502; break; }
+ case 504: {
+ if (la == null) { currentState = 504; break; }
if (la.kind == 40) {
- stateStack.Push(501);
- goto case 378;
+ stateStack.Push(503);
+ goto case 380;
} else {
isMissingModifier = true;
- goto case 503;
+ goto case 505;
}
}
- case 503: {
+ case 505: {
SetIdentifierExpected(la);
- goto case 504;
+ goto case 506;
}
- case 504: {
- if (la == null) { currentState = 504; break; }
+ case 506: {
+ if (la == null) { currentState = 506; break; }
if (set[122].Get(la.kind)) {
- currentState = 628;
+ currentState = 630;
break;
} else {
isMissingModifier = false;
SetIdentifierExpected(la);
- goto case 505;
+ goto case 507;
}
}
- case 505: {
- if (la == null) { currentState = 505; break; }
+ case 507: {
+ if (la == null) { currentState = 507; break; }
if (la.kind == 84 || la.kind == 155 || la.kind == 209) {
- stateStack.Push(495);
- goto case 485;
+ stateStack.Push(497);
+ goto case 487;
} else {
if (la.kind == 103) {
- stateStack.Push(495);
- goto case 473;
+ stateStack.Push(497);
+ goto case 475;
} else {
if (la.kind == 115) {
- stateStack.Push(495);
- goto case 463;
+ stateStack.Push(497);
+ goto case 465;
} else {
if (la.kind == 142) {
- stateStack.Push(495);
- goto case 462;
+ stateStack.Push(497);
+ goto case 464;
} else {
if (set[98].Get(la.kind)) {
- stateStack.Push(495);
+ stateStack.Push(497);
PushContext(Context.Member, la, t);
SetIdentifierExpected(la);
- goto case 506;
+ goto case 508;
} else {
Error(la);
- goto case 495;
+ goto case 497;
}
}
}
}
}
}
- case 506: {
- if (la == null) { currentState = 506; break; }
+ case 508: {
+ if (la == null) { currentState = 508; break; }
if (set[113].Get(la.kind)) {
- stateStack.Push(507);
- goto case 617;
+ stateStack.Push(509);
+ goto case 619;
} else {
if (la.kind == 127 || la.kind == 210) {
- stateStack.Push(507);
- goto case 603;
+ stateStack.Push(509);
+ goto case 605;
} else {
if (la.kind == 101) {
- stateStack.Push(507);
- goto case 587;
+ stateStack.Push(509);
+ goto case 589;
} else {
if (la.kind == 119) {
- stateStack.Push(507);
- goto case 575;
+ stateStack.Push(509);
+ goto case 577;
} else {
if (la.kind == 98) {
- stateStack.Push(507);
- goto case 563;
+ stateStack.Push(509);
+ goto case 565;
} else {
if (la.kind == 186) {
- stateStack.Push(507);
- goto case 521;
+ stateStack.Push(509);
+ goto case 523;
} else {
if (la.kind == 172) {
- stateStack.Push(507);
- goto case 508;
+ stateStack.Push(509);
+ goto case 510;
} else {
Error(la);
- goto case 507;
+ goto case 509;
}
}
}
@@ -6429,768 +6442,768 @@ partial class ExpressionFinder {
}
}
}
- case 507: {
+ case 509: {
PopContext();
currentState = stateStack.Pop();
goto switchlbl;
}
- case 508: {
- if (la == null) { currentState = 508; break; }
- Expect(172, la); // "Operator"
- currentState = 509;
- break;
- }
- case 509: {
- PushContext(Context.Identifier, la, t);
- SetIdentifierExpected(la);
- goto case 510;
- }
case 510: {
if (la == null) { currentState = 510; break; }
+ Expect(172, la); // "Operator"
currentState = 511;
break;
}
case 511: {
- PopContext();
+ PushContext(Context.Identifier, la, t);
+ SetIdentifierExpected(la);
goto case 512;
}
case 512: {
if (la == null) { currentState = 512; break; }
- Expect(37, la); // "("
currentState = 513;
break;
}
case 513: {
- stateStack.Push(514);
- goto case 365;
+ PopContext();
+ goto case 514;
}
case 514: {
if (la == null) { currentState = 514; break; }
- Expect(38, la); // ")"
+ Expect(37, la); // "("
currentState = 515;
break;
}
case 515: {
- if (la == null) { currentState = 515; break; }
+ stateStack.Push(516);
+ goto case 367;
+ }
+ case 516: {
+ if (la == null) { currentState = 516; break; }
+ Expect(38, la); // ")"
+ currentState = 517;
+ break;
+ }
+ case 517: {
+ if (la == null) { currentState = 517; break; }
if (la.kind == 63) {
- currentState = 519;
+ currentState = 521;
break;
} else {
- goto case 516;
+ goto case 518;
}
}
- case 516: {
- stateStack.Push(517);
- goto case 222;
+ case 518: {
+ stateStack.Push(519);
+ goto case 224;
}
- case 517: {
- if (la == null) { currentState = 517; break; }
+ case 519: {
+ if (la == null) { currentState = 519; break; }
Expect(113, la); // "End"
- currentState = 518;
+ currentState = 520;
break;
}
- case 518: {
- if (la == null) { currentState = 518; break; }
+ case 520: {
+ if (la == null) { currentState = 520; break; }
Expect(172, la); // "Operator"
currentState = 18;
break;
}
- case 519: {
- if (la == null) { currentState = 519; break; }
+ case 521: {
+ if (la == null) { currentState = 521; break; }
if (la.kind == 40) {
- stateStack.Push(519);
- goto case 378;
+ stateStack.Push(521);
+ goto case 380;
} else {
PushContext(Context.Type, la, t);
- stateStack.Push(520);
+ stateStack.Push(522);
goto case 32;
}
}
- case 520: {
+ case 522: {
PopContext();
- goto case 516;
+ goto case 518;
}
- case 521: {
- if (la == null) { currentState = 521; break; }
+ case 523: {
+ if (la == null) { currentState = 523; break; }
Expect(186, la); // "Property"
- currentState = 522;
+ currentState = 524;
break;
}
- case 522: {
+ case 524: {
PushContext(Context.Identifier, la, t);
SetIdentifierExpected(la);
- stateStack.Push(523);
- goto case 167;
+ stateStack.Push(525);
+ goto case 169;
}
- case 523: {
+ case 525: {
PopContext();
- goto case 524;
+ goto case 526;
}
- case 524: {
- if (la == null) { currentState = 524; break; }
+ case 526: {
+ if (la == null) { currentState = 526; break; }
if (la.kind == 37) {
- currentState = 560;
+ currentState = 562;
break;
} else {
- goto case 525;
+ goto case 527;
}
}
- case 525: {
- if (la == null) { currentState = 525; break; }
+ case 527: {
+ if (la == null) { currentState = 527; break; }
if (la.kind == 63) {
- currentState = 558;
+ currentState = 560;
break;
} else {
- goto case 526;
+ goto case 528;
}
}
- case 526: {
- if (la == null) { currentState = 526; break; }
+ case 528: {
+ if (la == null) { currentState = 528; break; }
if (la.kind == 136) {
- currentState = 556;
+ currentState = 558;
break;
} else {
- goto case 527;
+ goto case 529;
}
}
- case 527: {
- if (la == null) { currentState = 527; break; }
+ case 529: {
+ if (la == null) { currentState = 529; break; }
if (la.kind == 20) {
- currentState = 555;
+ currentState = 557;
break;
} else {
- goto case 528;
+ goto case 530;
}
}
- case 528: {
- stateStack.Push(529);
+ case 530: {
+ stateStack.Push(531);
goto case 18;
}
- case 529: {
+ case 531: {
PopContext();
- goto case 530;
+ goto case 532;
}
- case 530: {
- if (la == null) { currentState = 530; break; }
+ case 532: {
+ if (la == null) { currentState = 532; break; }
if (la.kind == 40) {
- stateStack.Push(530);
- goto case 378;
+ stateStack.Push(532);
+ goto case 380;
} else {
- goto case 531;
+ goto case 533;
}
}
- case 531: {
- if (la == null) { currentState = 531; break; }
+ case 533: {
+ if (la == null) { currentState = 533; break; }
if (set[143].Get(la.kind)) {
- currentState = 554;
+ currentState = 556;
break;
} else {
if (la.kind == 128 || la.kind == 198) {
PushContext(Context.Member, la, t);
- goto case 532;
+ goto case 534;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
}
- case 532: {
- if (la == null) { currentState = 532; break; }
+ case 534: {
+ if (la == null) { currentState = 534; break; }
if (la.kind == 128) {
- currentState = 533;
+ currentState = 535;
break;
} else {
if (la.kind == 198) {
- currentState = 533;
+ currentState = 535;
break;
} else {
Error(la);
- goto case 533;
+ goto case 535;
}
}
}
- case 533: {
- if (la == null) { currentState = 533; break; }
+ case 535: {
+ if (la == null) { currentState = 535; break; }
if (la.kind == 37) {
- currentState = 551;
+ currentState = 553;
break;
} else {
- goto case 534;
+ goto case 536;
}
}
- case 534: {
- stateStack.Push(535);
- goto case 222;
+ case 536: {
+ stateStack.Push(537);
+ goto case 224;
}
- case 535: {
- if (la == null) { currentState = 535; break; }
+ case 537: {
+ if (la == null) { currentState = 537; break; }
Expect(113, la); // "End"
- currentState = 536;
+ currentState = 538;
break;
}
- case 536: {
- if (la == null) { currentState = 536; break; }
+ case 538: {
+ if (la == null) { currentState = 538; break; }
if (la.kind == 128) {
- currentState = 537;
+ currentState = 539;
break;
} else {
if (la.kind == 198) {
- currentState = 537;
+ currentState = 539;
break;
} else {
Error(la);
- goto case 537;
+ goto case 539;
}
}
}
- case 537: {
- stateStack.Push(538);
+ case 539: {
+ stateStack.Push(540);
goto case 18;
}
- case 538: {
- if (la == null) { currentState = 538; break; }
+ case 540: {
+ if (la == null) { currentState = 540; break; }
if (set[104].Get(la.kind)) {
- goto case 541;
+ goto case 543;
} else {
- goto case 539;
+ goto case 541;
}
}
- case 539: {
- if (la == null) { currentState = 539; break; }
+ case 541: {
+ if (la == null) { currentState = 541; break; }
Expect(113, la); // "End"
- currentState = 540;
+ currentState = 542;
break;
}
- case 540: {
- if (la == null) { currentState = 540; break; }
+ case 542: {
+ if (la == null) { currentState = 542; break; }
Expect(186, la); // "Property"
currentState = 18;
break;
}
- case 541: {
- if (la == null) { currentState = 541; break; }
+ case 543: {
+ if (la == null) { currentState = 543; break; }
if (la.kind == 40) {
- stateStack.Push(541);
- goto case 378;
+ stateStack.Push(543);
+ goto case 380;
} else {
- goto case 542;
+ goto case 544;
}
}
- case 542: {
- if (la == null) { currentState = 542; break; }
+ case 544: {
+ if (la == null) { currentState = 544; break; }
if (set[143].Get(la.kind)) {
- currentState = 542;
+ currentState = 544;
break;
} else {
if (la.kind == 128) {
- currentState = 543;
+ currentState = 545;
break;
} else {
if (la.kind == 198) {
- currentState = 543;
+ currentState = 545;
break;
} else {
Error(la);
- goto case 543;
+ goto case 545;
}
}
}
}
- case 543: {
- if (la == null) { currentState = 543; break; }
+ case 545: {
+ if (la == null) { currentState = 545; break; }
if (la.kind == 37) {
- currentState = 548;
+ currentState = 550;
break;
} else {
- goto case 544;
+ goto case 546;
}
}
- case 544: {
- stateStack.Push(545);
- goto case 222;
+ case 546: {
+ stateStack.Push(547);
+ goto case 224;
}
- case 545: {
- if (la == null) { currentState = 545; break; }
+ case 547: {
+ if (la == null) { currentState = 547; break; }
Expect(113, la); // "End"
- currentState = 546;
+ currentState = 548;
break;
}
- case 546: {
- if (la == null) { currentState = 546; break; }
+ case 548: {
+ if (la == null) { currentState = 548; break; }
if (la.kind == 128) {
- currentState = 547;
+ currentState = 549;
break;
} else {
if (la.kind == 198) {
- currentState = 547;
+ currentState = 549;
break;
} else {
Error(la);
- goto case 547;
+ goto case 549;
}
}
}
- case 547: {
- stateStack.Push(539);
+ case 549: {
+ stateStack.Push(541);
goto case 18;
}
- case 548: {
+ case 550: {
SetIdentifierExpected(la);
- goto case 549;
+ goto case 551;
}
- case 549: {
- if (la == null) { currentState = 549; break; }
+ case 551: {
+ if (la == null) { currentState = 551; break; }
if (set[72].Get(la.kind)) {
- stateStack.Push(550);
- goto case 365;
+ stateStack.Push(552);
+ goto case 367;
} else {
- goto case 550;
+ goto case 552;
}
}
- case 550: {
- if (la == null) { currentState = 550; break; }
+ case 552: {
+ if (la == null) { currentState = 552; break; }
Expect(38, la); // ")"
- currentState = 544;
+ currentState = 546;
break;
}
- case 551: {
+ case 553: {
SetIdentifierExpected(la);
- goto case 552;
+ goto case 554;
}
- case 552: {
- if (la == null) { currentState = 552; break; }
+ case 554: {
+ if (la == null) { currentState = 554; break; }
if (set[72].Get(la.kind)) {
- stateStack.Push(553);
- goto case 365;
+ stateStack.Push(555);
+ goto case 367;
} else {
- goto case 553;
+ goto case 555;
}
}
- case 553: {
- if (la == null) { currentState = 553; break; }
+ case 555: {
+ if (la == null) { currentState = 555; break; }
Expect(38, la); // ")"
- currentState = 534;
+ currentState = 536;
break;
}
- case 554: {
+ case 556: {
SetIdentifierExpected(la);
- goto case 531;
+ goto case 533;
}
- case 555: {
- stateStack.Push(528);
- goto case 49;
+ case 557: {
+ stateStack.Push(530);
+ goto case 51;
}
- case 556: {
- stateStack.Push(557);
+ case 558: {
+ stateStack.Push(559);
goto case 32;
}
- case 557: {
- if (la == null) { currentState = 557; break; }
+ case 559: {
+ if (la == null) { currentState = 559; break; }
if (la.kind == 22) {
- currentState = 556;
+ currentState = 558;
break;
} else {
- goto case 527;
+ goto case 529;
}
}
- case 558: {
- if (la == null) { currentState = 558; break; }
+ case 560: {
+ if (la == null) { currentState = 560; break; }
if (la.kind == 40) {
- stateStack.Push(558);
- goto case 378;
+ stateStack.Push(560);
+ goto case 380;
} else {
if (la.kind == 162) {
- stateStack.Push(526);
- goto case 60;
+ stateStack.Push(528);
+ goto case 62;
} else {
if (set[15].Get(la.kind)) {
PushContext(Context.Type, la, t);
- stateStack.Push(559);
+ stateStack.Push(561);
goto case 32;
} else {
Error(la);
- goto case 526;
+ goto case 528;
}
}
}
}
- case 559: {
+ case 561: {
PopContext();
- goto case 526;
+ goto case 528;
}
- case 560: {
+ case 562: {
SetIdentifierExpected(la);
- goto case 561;
+ goto case 563;
}
- case 561: {
- if (la == null) { currentState = 561; break; }
+ case 563: {
+ if (la == null) { currentState = 563; break; }
if (set[72].Get(la.kind)) {
- stateStack.Push(562);
- goto case 365;
+ stateStack.Push(564);
+ goto case 367;
} else {
- goto case 562;
+ goto case 564;
}
}
- case 562: {
- if (la == null) { currentState = 562; break; }
+ case 564: {
+ if (la == null) { currentState = 564; break; }
Expect(38, la); // ")"
- currentState = 525;
+ currentState = 527;
break;
}
- case 563: {
- if (la == null) { currentState = 563; break; }
+ case 565: {
+ if (la == null) { currentState = 565; break; }
Expect(98, la); // "Custom"
- currentState = 564;
+ currentState = 566;
break;
}
- case 564: {
- stateStack.Push(565);
- goto case 575;
+ case 566: {
+ stateStack.Push(567);
+ goto case 577;
}
- case 565: {
- if (la == null) { currentState = 565; break; }
+ case 567: {
+ if (la == null) { currentState = 567; break; }
if (set[109].Get(la.kind)) {
- goto case 567;
+ goto case 569;
} else {
Expect(113, la); // "End"
- currentState = 566;
+ currentState = 568;
break;
}
}
- case 566: {
- if (la == null) { currentState = 566; break; }
+ case 568: {
+ if (la == null) { currentState = 568; break; }
Expect(119, la); // "Event"
currentState = 18;
break;
}
- case 567: {
- if (la == null) { currentState = 567; break; }
+ case 569: {
+ if (la == null) { currentState = 569; break; }
if (la.kind == 40) {
- stateStack.Push(567);
- goto case 378;
+ stateStack.Push(569);
+ goto case 380;
} else {
if (la.kind == 56) {
- currentState = 568;
+ currentState = 570;
break;
} else {
if (la.kind == 193) {
- currentState = 568;
+ currentState = 570;
break;
} else {
if (la.kind == 189) {
- currentState = 568;
+ currentState = 570;
break;
} else {
Error(la);
- goto case 568;
+ goto case 570;
}
}
}
}
}
- case 568: {
- if (la == null) { currentState = 568; break; }
- Expect(37, la); // "("
- currentState = 569;
- break;
- }
- case 569: {
- stateStack.Push(570);
- goto case 365;
- }
case 570: {
if (la == null) { currentState = 570; break; }
- Expect(38, la); // ")"
+ Expect(37, la); // "("
currentState = 571;
break;
}
case 571: {
stateStack.Push(572);
- goto case 222;
+ goto case 367;
}
case 572: {
if (la == null) { currentState = 572; break; }
- Expect(113, la); // "End"
+ Expect(38, la); // ")"
currentState = 573;
break;
}
case 573: {
- if (la == null) { currentState = 573; break; }
+ stateStack.Push(574);
+ goto case 224;
+ }
+ case 574: {
+ if (la == null) { currentState = 574; break; }
+ Expect(113, la); // "End"
+ currentState = 575;
+ break;
+ }
+ case 575: {
+ if (la == null) { currentState = 575; break; }
if (la.kind == 56) {
- currentState = 574;
+ currentState = 576;
break;
} else {
if (la.kind == 193) {
- currentState = 574;
+ currentState = 576;
break;
} else {
if (la.kind == 189) {
- currentState = 574;
+ currentState = 576;
break;
} else {
Error(la);
- goto case 574;
+ goto case 576;
}
}
}
}
- case 574: {
- stateStack.Push(565);
+ case 576: {
+ stateStack.Push(567);
goto case 18;
}
- case 575: {
- if (la == null) { currentState = 575; break; }
+ case 577: {
+ if (la == null) { currentState = 577; break; }
Expect(119, la); // "Event"
- currentState = 576;
+ currentState = 578;
break;
}
- case 576: {
+ case 578: {
PushContext(Context.Identifier, la, t);
SetIdentifierExpected(la);
- stateStack.Push(577);
- goto case 167;
+ stateStack.Push(579);
+ goto case 169;
}
- case 577: {
+ case 579: {
PopContext();
- goto case 578;
+ goto case 580;
}
- case 578: {
- if (la == null) { currentState = 578; break; }
+ case 580: {
+ if (la == null) { currentState = 580; break; }
if (la.kind == 63) {
- currentState = 585;
+ currentState = 587;
break;
} else {
if (set[144].Get(la.kind)) {
if (la.kind == 37) {
- currentState = 582;
+ currentState = 584;
break;
} else {
- goto case 579;
+ goto case 581;
}
} else {
Error(la);
- goto case 579;
+ goto case 581;
}
}
}
- case 579: {
- if (la == null) { currentState = 579; break; }
+ case 581: {
+ if (la == null) { currentState = 581; break; }
if (la.kind == 136) {
- currentState = 580;
+ currentState = 582;
break;
} else {
goto case 18;
}
}
- case 580: {
- stateStack.Push(581);
+ case 582: {
+ stateStack.Push(583);
goto case 32;
}
- case 581: {
- if (la == null) { currentState = 581; break; }
+ case 583: {
+ if (la == null) { currentState = 583; break; }
if (la.kind == 22) {
- currentState = 580;
+ currentState = 582;
break;
} else {
goto case 18;
}
}
- case 582: {
+ case 584: {
SetIdentifierExpected(la);
- goto case 583;
+ goto case 585;
}
- case 583: {
- if (la == null) { currentState = 583; break; }
+ case 585: {
+ if (la == null) { currentState = 585; break; }
if (set[72].Get(la.kind)) {
- stateStack.Push(584);
- goto case 365;
+ stateStack.Push(586);
+ goto case 367;
} else {
- goto case 584;
+ goto case 586;
}
}
- case 584: {
- if (la == null) { currentState = 584; break; }
+ case 586: {
+ if (la == null) { currentState = 586; break; }
Expect(38, la); // ")"
- currentState = 579;
+ currentState = 581;
break;
}
- case 585: {
+ case 587: {
PushContext(Context.Type, la, t);
- stateStack.Push(586);
+ stateStack.Push(588);
goto case 32;
}
- case 586: {
+ case 588: {
PopContext();
- goto case 579;
+ goto case 581;
}
- case 587: {
- if (la == null) { currentState = 587; break; }
+ case 589: {
+ if (la == null) { currentState = 589; break; }
Expect(101, la); // "Declare"
- currentState = 588;
+ currentState = 590;
break;
}
- case 588: {
- if (la == null) { currentState = 588; break; }
+ case 590: {
+ if (la == null) { currentState = 590; break; }
if (la.kind == 62 || la.kind == 66 || la.kind == 223) {
- currentState = 589;
+ currentState = 591;
break;
} else {
- goto case 589;
+ goto case 591;
}
}
- case 589: {
- if (la == null) { currentState = 589; break; }
+ case 591: {
+ if (la == null) { currentState = 591; break; }
if (la.kind == 210) {
- currentState = 590;
+ currentState = 592;
break;
} else {
if (la.kind == 127) {
- currentState = 590;
+ currentState = 592;
break;
} else {
Error(la);
- goto case 590;
+ goto case 592;
}
}
}
- case 590: {
+ case 592: {
PushContext(Context.Identifier, la, t);
SetIdentifierExpected(la);
- stateStack.Push(591);
- goto case 167;
+ stateStack.Push(593);
+ goto case 169;
}
- case 591: {
+ case 593: {
PopContext();
- goto case 592;
+ goto case 594;
}
- case 592: {
- if (la == null) { currentState = 592; break; }
+ case 594: {
+ if (la == null) { currentState = 594; break; }
Expect(149, la); // "Lib"
- currentState = 593;
+ currentState = 595;
break;
}
- case 593: {
- if (la == null) { currentState = 593; break; }
+ case 595: {
+ if (la == null) { currentState = 595; break; }
Expect(3, la); // LiteralString
- currentState = 594;
+ currentState = 596;
break;
}
- case 594: {
- if (la == null) { currentState = 594; break; }
+ case 596: {
+ if (la == null) { currentState = 596; break; }
if (la.kind == 59) {
- currentState = 602;
+ currentState = 604;
break;
} else {
- goto case 595;
+ goto case 597;
}
}
- case 595: {
- if (la == null) { currentState = 595; break; }
+ case 597: {
+ if (la == null) { currentState = 597; break; }
if (la.kind == 37) {
- currentState = 599;
+ currentState = 601;
break;
} else {
- goto case 596;
+ goto case 598;
}
}
- case 596: {
- if (la == null) { currentState = 596; break; }
+ case 598: {
+ if (la == null) { currentState = 598; break; }
if (la.kind == 63) {
- currentState = 597;
+ currentState = 599;
break;
} else {
goto case 18;
}
}
- case 597: {
+ case 599: {
PushContext(Context.Type, la, t);
- stateStack.Push(598);
+ stateStack.Push(600);
goto case 32;
}
- case 598: {
+ case 600: {
PopContext();
goto case 18;
}
- case 599: {
+ case 601: {
SetIdentifierExpected(la);
- goto case 600;
+ goto case 602;
}
- case 600: {
- if (la == null) { currentState = 600; break; }
+ case 602: {
+ if (la == null) { currentState = 602; break; }
if (set[72].Get(la.kind)) {
- stateStack.Push(601);
- goto case 365;
+ stateStack.Push(603);
+ goto case 367;
} else {
- goto case 601;
+ goto case 603;
}
}
- case 601: {
- if (la == null) { currentState = 601; break; }
+ case 603: {
+ if (la == null) { currentState = 603; break; }
Expect(38, la); // ")"
- currentState = 596;
+ currentState = 598;
break;
}
- case 602: {
- if (la == null) { currentState = 602; break; }
+ case 604: {
+ if (la == null) { currentState = 604; break; }
Expect(3, la); // LiteralString
- currentState = 595;
+ currentState = 597;
break;
}
- case 603: {
- if (la == null) { currentState = 603; break; }
+ case 605: {
+ if (la == null) { currentState = 605; break; }
if (la.kind == 210) {
- currentState = 604;
+ currentState = 606;
break;
} else {
if (la.kind == 127) {
- currentState = 604;
+ currentState = 606;
break;
} else {
Error(la);
- goto case 604;
+ goto case 606;
}
}
}
- case 604: {
+ case 606: {
PushContext(Context.Identifier, la, t);
SetIdentifierExpected(la);
- goto case 605;
+ goto case 607;
}
- case 605: {
- if (la == null) { currentState = 605; break; }
- currentState = 606;
+ case 607: {
+ if (la == null) { currentState = 607; break; }
+ currentState = 608;
break;
}
- case 606: {
+ case 608: {
PopContext();
- goto case 607;
+ goto case 609;
}
- case 607: {
- if (la == null) { currentState = 607; break; }
+ case 609: {
+ if (la == null) { currentState = 609; break; }
if (la.kind == 37) {
- currentState = 613;
+ currentState = 615;
break;
} else {
if (la.kind == 63) {
- currentState = 611;
+ currentState = 613;
break;
} else {
- goto case 608;
+ goto case 610;
}
}
}
- case 608: {
- stateStack.Push(609);
- goto case 222;
+ case 610: {
+ stateStack.Push(611);
+ goto case 224;
}
- case 609: {
- if (la == null) { currentState = 609; break; }
+ case 611: {
+ if (la == null) { currentState = 611; break; }
Expect(113, la); // "End"
- currentState = 610;
+ currentState = 612;
break;
}
- case 610: {
- if (la == null) { currentState = 610; break; }
+ case 612: {
+ if (la == null) { currentState = 612; break; }
if (la.kind == 210) {
currentState = 18;
break;
@@ -7199,391 +7212,391 @@ partial class ExpressionFinder {
currentState = 18;
break;
} else {
- goto case 458;
+ goto case 460;
}
}
}
- case 611: {
+ case 613: {
PushContext(Context.Type, la, t);
- stateStack.Push(612);
+ stateStack.Push(614);
goto case 32;
}
- case 612: {
+ case 614: {
PopContext();
- goto case 608;
+ goto case 610;
}
- case 613: {
+ case 615: {
SetIdentifierExpected(la);
- goto case 614;
+ goto case 616;
}
- case 614: {
- if (la == null) { currentState = 614; break; }
+ case 616: {
+ if (la == null) { currentState = 616; break; }
if (set[142].Get(la.kind)) {
if (la.kind == 169) {
- currentState = 616;
+ currentState = 618;
break;
} else {
if (set[72].Get(la.kind)) {
- stateStack.Push(615);
- goto case 365;
+ stateStack.Push(617);
+ goto case 367;
} else {
Error(la);
- goto case 615;
+ goto case 617;
}
}
} else {
- goto case 615;
+ goto case 617;
}
}
- case 615: {
- if (la == null) { currentState = 615; break; }
+ case 617: {
+ if (la == null) { currentState = 617; break; }
Expect(38, la); // ")"
- currentState = 607;
+ currentState = 609;
break;
}
- case 616: {
- stateStack.Push(615);
- goto case 428;
+ case 618: {
+ stateStack.Push(617);
+ goto case 430;
}
- case 617: {
- stateStack.Push(618);
+ case 619: {
+ stateStack.Push(620);
SetIdentifierExpected(la);
- goto case 619;
+ goto case 621;
}
- case 618: {
- if (la == null) { currentState = 618; break; }
+ case 620: {
+ if (la == null) { currentState = 620; break; }
if (la.kind == 22) {
- currentState = 617;
+ currentState = 619;
break;
} else {
goto case 18;
}
}
- case 619: {
- if (la == null) { currentState = 619; break; }
+ case 621: {
+ if (la == null) { currentState = 621; break; }
if (la.kind == 88) {
- currentState = 620;
+ currentState = 622;
break;
} else {
- goto case 620;
+ goto case 622;
}
}
- case 620: {
+ case 622: {
PushContext(Context.Identifier, la, t);
SetIdentifierExpected(la);
- stateStack.Push(621);
- goto case 627;
+ stateStack.Push(623);
+ goto case 629;
}
- case 621: {
+ case 623: {
PopContext();
- goto case 622;
+ goto case 624;
}
- case 622: {
- if (la == null) { currentState = 622; break; }
+ case 624: {
+ if (la == null) { currentState = 624; break; }
if (la.kind == 63) {
- currentState = 624;
+ currentState = 626;
break;
} else {
- goto case 623;
+ goto case 625;
}
}
- case 623: {
- if (la == null) { currentState = 623; break; }
+ case 625: {
+ if (la == null) { currentState = 625; break; }
if (la.kind == 20) {
- goto case 180;
+ goto case 182;
} else {
currentState = stateStack.Pop();
goto switchlbl;
}
}
- case 624: {
+ case 626: {
PushContext(Context.Type, la, t);
- goto case 625;
+ goto case 627;
}
- case 625: {
- if (la == null) { currentState = 625; break; }
+ case 627: {
+ if (la == null) { currentState = 627; break; }
if (la.kind == 162) {
- stateStack.Push(626);
- goto case 60;
+ stateStack.Push(628);
+ goto case 62;
} else {
if (set[15].Get(la.kind)) {
- stateStack.Push(626);
+ stateStack.Push(628);
goto case 32;
} else {
Error(la);
- goto case 626;
+ goto case 628;
}
}
}
- case 626: {
+ case 628: {
PopContext();
- goto case 623;
+ goto case 625;
}
- case 627: {
- if (la == null) { currentState = 627; break; }
+ case 629: {
+ if (la == null) { currentState = 629; break; }
if (set[128].Get(la.kind)) {
currentState = stateStack.Pop();
break;
} else {
if (la.kind == 58) {
- goto case 117;
+ goto case 119;
} else {
if (la.kind == 126) {
- goto case 101;
+ goto case 103;
} else {
goto case 6;
}
}
}
}
- case 628: {
+ case 630: {
isMissingModifier = false;
- goto case 503;
+ goto case 505;
}
- case 629: {
- if (la == null) { currentState = 629; break; }
+ case 631: {
+ if (la == null) { currentState = 631; break; }
Expect(136, la); // "Implements"
- currentState = 630;
+ currentState = 632;
break;
}
- case 630: {
+ case 632: {
PushContext(Context.Type, la, t);
- stateStack.Push(631);
+ stateStack.Push(633);
goto case 32;
}
- case 631: {
+ case 633: {
PopContext();
- goto case 632;
+ goto case 634;
}
- case 632: {
- if (la == null) { currentState = 632; break; }
+ case 634: {
+ if (la == null) { currentState = 634; break; }
if (la.kind == 22) {
- currentState = 633;
+ currentState = 635;
break;
} else {
- stateStack.Push(495);
+ stateStack.Push(497);
goto case 18;
}
}
- case 633: {
+ case 635: {
PushContext(Context.Type, la, t);
- stateStack.Push(634);
+ stateStack.Push(636);
goto case 32;
}
- case 634: {
+ case 636: {
PopContext();
- goto case 632;
+ goto case 634;
}
- case 635: {
- if (la == null) { currentState = 635; break; }
+ case 637: {
+ if (la == null) { currentState = 637; break; }
Expect(140, la); // "Inherits"
- currentState = 636;
+ currentState = 638;
break;
}
- case 636: {
+ case 638: {
PushContext(Context.Type, la, t);
- stateStack.Push(637);
+ stateStack.Push(639);
goto case 32;
}
- case 637: {
+ case 639: {
PopContext();
- stateStack.Push(493);
+ stateStack.Push(495);
goto case 18;
}
- case 638: {
- if (la == null) { currentState = 638; break; }
+ case 640: {
+ if (la == null) { currentState = 640; break; }
Expect(169, la); // "Of"
- currentState = 639;
+ currentState = 641;
break;
}
- case 639: {
- stateStack.Push(640);
- goto case 428;
+ case 641: {
+ stateStack.Push(642);
+ goto case 430;
}
- case 640: {
- if (la == null) { currentState = 640; break; }
+ case 642: {
+ if (la == null) { currentState = 642; break; }
Expect(38, la); // ")"
- currentState = 490;
+ currentState = 492;
break;
}
- case 641: {
+ case 643: {
isMissingModifier = false;
goto case 23;
}
- case 642: {
- if (la == null) { currentState = 642; break; }
+ case 644: {
+ if (la == null) { currentState = 644; break; }
Expect(140, la); // "Inherits"
- currentState = 643;
+ currentState = 645;
break;
}
- case 643: {
- stateStack.Push(644);
+ case 645: {
+ stateStack.Push(646);
goto case 32;
}
- case 644: {
+ case 646: {
PopContext();
- goto case 645;
+ goto case 647;
}
- case 645: {
- if (la == null) { currentState = 645; break; }
+ case 647: {
+ if (la == null) { currentState = 647; break; }
if (la.kind == 22) {
- currentState = 646;
+ currentState = 648;
break;
} else {
stateStack.Push(14);
goto case 18;
}
}
- case 646: {
+ case 648: {
PushContext(Context.Type, la, t);
- stateStack.Push(647);
+ stateStack.Push(649);
goto case 32;
}
- case 647: {
+ case 649: {
PopContext();
- goto case 645;
+ goto case 647;
}
- case 648: {
- if (la == null) { currentState = 648; break; }
+ case 650: {
+ if (la == null) { currentState = 650; break; }
Expect(169, la); // "Of"
- currentState = 649;
+ currentState = 651;
break;
}
- case 649: {
- stateStack.Push(650);
- goto case 428;
+ case 651: {
+ stateStack.Push(652);
+ goto case 430;
}
- case 650: {
- if (la == null) { currentState = 650; break; }
+ case 652: {
+ if (la == null) { currentState = 652; break; }
Expect(38, la); // ")"
currentState = 11;
break;
}
- case 651: {
+ case 653: {
PushContext(Context.Identifier, la, t);
SetIdentifierExpected(la);
- goto case 652;
+ goto case 654;
}
- case 652: {
- if (la == null) { currentState = 652; break; }
+ case 654: {
+ if (la == null) { currentState = 654; break; }
if (set[45].Get(la.kind)) {
- currentState = 652;
+ currentState = 654;
break;
} else {
PopContext();
- stateStack.Push(653);
+ stateStack.Push(655);
goto case 18;
}
}
- case 653: {
- if (la == null) { currentState = 653; break; }
+ case 655: {
+ if (la == null) { currentState = 655; break; }
if (set[3].Get(la.kind)) {
- stateStack.Push(653);
+ stateStack.Push(655);
goto case 5;
} else {
Expect(113, la); // "End"
- currentState = 654;
+ currentState = 656;
break;
}
}
- case 654: {
- if (la == null) { currentState = 654; break; }
+ case 656: {
+ if (la == null) { currentState = 656; break; }
Expect(160, la); // "Namespace"
currentState = 18;
break;
}
- case 655: {
- if (la == null) { currentState = 655; break; }
+ case 657: {
+ if (la == null) { currentState = 657; break; }
Expect(137, la); // "Imports"
- currentState = 656;
+ currentState = 658;
break;
}
- case 656: {
+ case 658: {
PushContext(Context.Importable, la, t);
nextTokenIsStartOfImportsOrAccessExpression = true;
- goto case 657;
+ goto case 659;
}
- case 657: {
- if (la == null) { currentState = 657; break; }
+ case 659: {
+ if (la == null) { currentState = 659; break; }
if (set[145].Get(la.kind)) {
- currentState = 663;
+ currentState = 665;
break;
} else {
if (la.kind == 10) {
- currentState = 659;
+ currentState = 661;
break;
} else {
Error(la);
- goto case 658;
+ goto case 660;
}
}
}
- case 658: {
+ case 660: {
PopContext();
goto case 18;
}
- case 659: {
- stateStack.Push(660);
- goto case 167;
+ case 661: {
+ stateStack.Push(662);
+ goto case 169;
}
- case 660: {
- if (la == null) { currentState = 660; break; }
+ case 662: {
+ if (la == null) { currentState = 662; break; }
Expect(20, la); // "="
- currentState = 661;
+ currentState = 663;
break;
}
- case 661: {
- if (la == null) { currentState = 661; break; }
+ case 663: {
+ if (la == null) { currentState = 663; break; }
Expect(3, la); // LiteralString
- currentState = 662;
+ currentState = 664;
break;
}
- case 662: {
- if (la == null) { currentState = 662; break; }
+ case 664: {
+ if (la == null) { currentState = 664; break; }
Expect(11, la); // XmlCloseTag
- currentState = 658;
+ currentState = 660;
break;
}
- case 663: {
- if (la == null) { currentState = 663; break; }
+ case 665: {
+ if (la == null) { currentState = 665; break; }
if (la.kind == 37) {
- stateStack.Push(663);
+ stateStack.Push(665);
goto case 37;
} else {
if (la.kind == 20 || la.kind == 26) {
- currentState = 664;
+ currentState = 666;
break;
} else {
- goto case 658;
+ goto case 660;
}
}
}
- case 664: {
- stateStack.Push(658);
+ case 666: {
+ stateStack.Push(660);
goto case 32;
}
- case 665: {
- if (la == null) { currentState = 665; break; }
+ case 667: {
+ if (la == null) { currentState = 667; break; }
Expect(173, la); // "Option"
- currentState = 666;
+ currentState = 668;
break;
}
- case 666: {
- if (la == null) { currentState = 666; break; }
+ case 668: {
+ if (la == null) { currentState = 668; break; }
if (la.kind == 121 || la.kind == 139 || la.kind == 207) {
- currentState = 668;
+ currentState = 670;
break;
} else {
if (la.kind == 87) {
- currentState = 667;
+ currentState = 669;
break;
} else {
- goto case 458;
+ goto case 460;
}
}
}
- case 667: {
- if (la == null) { currentState = 667; break; }
+ case 669: {
+ if (la == null) { currentState = 669; break; }
if (la.kind == 213) {
currentState = 18;
break;
@@ -7592,12 +7605,12 @@ partial class ExpressionFinder {
currentState = 18;
break;
} else {
- goto case 458;
+ goto case 460;
}
}
}
- case 668: {
- if (la == null) { currentState = 668; break; }
+ case 670: {
+ if (la == null) { currentState = 670; break; }
if (la.kind == 170 || la.kind == 171) {
currentState = 18;
break;
diff --git a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
index 40410f80b7..547675c805 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
+++ b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
@@ -72,11 +72,12 @@ IsGlobalAttrTarget()) {
}
void EndOfStmt() {
+ while (!(la.kind == 0 || la.kind == 1 || la.kind == 21)) {SynErr(239); lexer.NextToken(); }
if (la.kind == 1) {
lexer.NextToken();
} else if (la.kind == 21) {
lexer.NextToken();
- } else SynErr(239);
+ } else SynErr(240);
}
void OptionStmt() {
@@ -119,7 +120,7 @@ ref val);
#line 285 "VBNET.ATG"
node = new OptionDeclaration(OptionType.CompareText, val);
- } else SynErr(240);
+ } else SynErr(241);
} else if (la.kind == 139) {
lexer.NextToken();
if (la.kind == 170 || la.kind == 171) {
@@ -130,7 +131,7 @@ ref val);
#line 289 "VBNET.ATG"
node = new OptionDeclaration(OptionType.Infer, val);
- } else SynErr(241);
+ } else SynErr(242);
EndOfStmt();
#line 293 "VBNET.ATG"
@@ -144,33 +145,33 @@ ref val);
void ImportsStmt() {
-#line 316 "VBNET.ATG"
+#line 314 "VBNET.ATG"
List usings = new List();
Expect(137);
-#line 320 "VBNET.ATG"
+#line 318 "VBNET.ATG"
Location startPos = t.Location;
Using u;
ImportClause(
-#line 323 "VBNET.ATG"
+#line 321 "VBNET.ATG"
out u);
-#line 323 "VBNET.ATG"
+#line 321 "VBNET.ATG"
if (u != null) { usings.Add(u); }
while (la.kind == 22) {
lexer.NextToken();
ImportClause(
-#line 325 "VBNET.ATG"
+#line 323 "VBNET.ATG"
out u);
-#line 325 "VBNET.ATG"
+#line 323 "VBNET.ATG"
if (u != null) { usings.Add(u); }
}
EndOfStmt();
-#line 329 "VBNET.ATG"
+#line 327 "VBNET.ATG"
UsingDeclaration usingDeclaration = new UsingDeclaration(usings);
usingDeclaration.StartLocation = startPos;
usingDeclaration.EndLocation = t.Location;
@@ -181,28 +182,28 @@ out u);
void GlobalAttributeSection() {
Expect(40);
-#line 2755 "VBNET.ATG"
+#line 2753 "VBNET.ATG"
Location startPos = t.Location;
if (la.kind == 65) {
lexer.NextToken();
} else if (la.kind == 155) {
lexer.NextToken();
- } else SynErr(242);
+ } else SynErr(243);
-#line 2757 "VBNET.ATG"
+#line 2755 "VBNET.ATG"
string attributeTarget = t.val != null ? t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture) : null;
List attributes = new List();
ASTAttribute attribute;
Expect(21);
Attribute(
-#line 2761 "VBNET.ATG"
+#line 2759 "VBNET.ATG"
out attribute);
-#line 2761 "VBNET.ATG"
+#line 2759 "VBNET.ATG"
attributes.Add(attribute);
while (
-#line 2762 "VBNET.ATG"
+#line 2760 "VBNET.ATG"
NotFinalComma()) {
if (la.kind == 22) {
lexer.NextToken();
@@ -210,14 +211,14 @@ NotFinalComma()) {
lexer.NextToken();
} else if (la.kind == 155) {
lexer.NextToken();
- } else SynErr(243);
+ } else SynErr(244);
Expect(21);
}
Attribute(
-#line 2762 "VBNET.ATG"
+#line 2760 "VBNET.ATG"
out attribute);
-#line 2762 "VBNET.ATG"
+#line 2760 "VBNET.ATG"
attributes.Add(attribute);
}
if (la.kind == 22) {
@@ -226,7 +227,7 @@ out attribute);
Expect(39);
EndOfStmt();
-#line 2767 "VBNET.ATG"
+#line 2765 "VBNET.ATG"
AttributeSection section = new AttributeSection {
AttributeTarget = attributeTarget,
Attributes = attributes,
@@ -239,7 +240,7 @@ out attribute);
void NamespaceMemberDecl() {
-#line 362 "VBNET.ATG"
+#line 360 "VBNET.ATG"
ModifierList m = new ModifierList();
AttributeSection section;
List attributes = new List();
@@ -248,14 +249,14 @@ out attribute);
if (la.kind == 160) {
lexer.NextToken();
-#line 369 "VBNET.ATG"
+#line 367 "VBNET.ATG"
Location startPos = t.Location;
Qualident(
-#line 371 "VBNET.ATG"
+#line 369 "VBNET.ATG"
out qualident);
-#line 373 "VBNET.ATG"
+#line 371 "VBNET.ATG"
INode node = new NamespaceDeclaration(qualident);
node.StartLocation = startPos;
AddChild(node);
@@ -264,28 +265,28 @@ out qualident);
EndOfStmt();
NamespaceBody();
-#line 381 "VBNET.ATG"
+#line 379 "VBNET.ATG"
node.EndLocation = t.Location;
BlockEnd();
} else if (StartOf(2)) {
while (la.kind == 40) {
AttributeSection(
-#line 385 "VBNET.ATG"
+#line 383 "VBNET.ATG"
out section);
-#line 385 "VBNET.ATG"
+#line 383 "VBNET.ATG"
attributes.Add(section);
}
while (StartOf(3)) {
TypeModifier(
-#line 386 "VBNET.ATG"
+#line 384 "VBNET.ATG"
m);
}
NonModuleDeclaration(
-#line 386 "VBNET.ATG"
+#line 384 "VBNET.ATG"
m, attributes);
- } else SynErr(244);
+ } else SynErr(245);
}
void OptionValue(
@@ -301,30 +302,30 @@ ref bool val) {
#line 305 "VBNET.ATG"
val = false;
- } else SynErr(245);
+ } else SynErr(246);
}
void ImportClause(
-#line 336 "VBNET.ATG"
+#line 334 "VBNET.ATG"
out Using u) {
-#line 338 "VBNET.ATG"
+#line 336 "VBNET.ATG"
string qualident = null;
TypeReference aliasedType = null;
u = null;
if (StartOf(4)) {
Qualident(
-#line 343 "VBNET.ATG"
+#line 341 "VBNET.ATG"
out qualident);
if (la.kind == 20) {
lexer.NextToken();
TypeName(
-#line 344 "VBNET.ATG"
+#line 342 "VBNET.ATG"
out aliasedType);
}
-#line 346 "VBNET.ATG"
+#line 344 "VBNET.ATG"
if (qualident != null && qualident.Length > 0) {
if (aliasedType != null) {
u = new Using(qualident, aliasedType);
@@ -335,64 +336,64 @@ out aliasedType);
} else if (la.kind == 10) {
-#line 354 "VBNET.ATG"
+#line 352 "VBNET.ATG"
string prefix = null;
lexer.NextToken();
Identifier();
-#line 355 "VBNET.ATG"
+#line 353 "VBNET.ATG"
prefix = t.val;
Expect(20);
Expect(3);
-#line 355 "VBNET.ATG"
+#line 353 "VBNET.ATG"
u = new Using(t.literalValue as string, prefix);
Expect(11);
- } else SynErr(246);
+ } else SynErr(247);
}
void Qualident(
-#line 3511 "VBNET.ATG"
+#line 3509 "VBNET.ATG"
out string qualident) {
-#line 3513 "VBNET.ATG"
+#line 3511 "VBNET.ATG"
string name;
qualidentBuilder.Length = 0;
Identifier();
-#line 3517 "VBNET.ATG"
+#line 3515 "VBNET.ATG"
qualidentBuilder.Append(t.val);
while (
-#line 3518 "VBNET.ATG"
+#line 3516 "VBNET.ATG"
DotAndIdentOrKw()) {
Expect(26);
IdentifierOrKeyword(
-#line 3518 "VBNET.ATG"
+#line 3516 "VBNET.ATG"
out name);
-#line 3518 "VBNET.ATG"
+#line 3516 "VBNET.ATG"
qualidentBuilder.Append('.'); qualidentBuilder.Append(name);
}
-#line 3520 "VBNET.ATG"
+#line 3518 "VBNET.ATG"
qualident = qualidentBuilder.ToString();
}
void TypeName(
-#line 2628 "VBNET.ATG"
+#line 2626 "VBNET.ATG"
out TypeReference typeref) {
-#line 2629 "VBNET.ATG"
+#line 2627 "VBNET.ATG"
ArrayList rank = null;
NonArrayTypeName(
-#line 2631 "VBNET.ATG"
+#line 2629 "VBNET.ATG"
out typeref, false);
ArrayTypeModifiers(
-#line 2635 "VBNET.ATG"
+#line 2633 "VBNET.ATG"
out rank);
-#line 2636 "VBNET.ATG"
+#line 2634 "VBNET.ATG"
if (rank != null && typeref != null) {
typeref.RankSpecifier = (int[])rank.ToArray(typeof(int));
}
@@ -404,7 +405,7 @@ out rank);
IdentifierForFieldDeclaration();
} else if (la.kind == 98) {
lexer.NextToken();
- } else SynErr(247);
+ } else SynErr(248);
}
void NamespaceBody() {
@@ -423,35 +424,35 @@ out rank);
}
void AttributeSection(
-#line 2830 "VBNET.ATG"
+#line 2828 "VBNET.ATG"
out AttributeSection section) {
-#line 2832 "VBNET.ATG"
+#line 2830 "VBNET.ATG"
string attributeTarget = "";List attributes = new List();
ASTAttribute attribute;
Expect(40);
-#line 2836 "VBNET.ATG"
+#line 2834 "VBNET.ATG"
Location startPos = t.Location;
if (
-#line 2837 "VBNET.ATG"
+#line 2835 "VBNET.ATG"
IsLocalAttrTarget()) {
if (la.kind == 119) {
lexer.NextToken();
-#line 2838 "VBNET.ATG"
+#line 2836 "VBNET.ATG"
attributeTarget = "event";
} else if (la.kind == 195) {
lexer.NextToken();
-#line 2839 "VBNET.ATG"
+#line 2837 "VBNET.ATG"
attributeTarget = "return";
} else {
Identifier();
-#line 2842 "VBNET.ATG"
+#line 2840 "VBNET.ATG"
string val = t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture);
if (val != "field" || val != "method" ||
val != "module" || val != "param" ||
@@ -464,20 +465,20 @@ IsLocalAttrTarget()) {
Expect(21);
}
Attribute(
-#line 2852 "VBNET.ATG"
+#line 2850 "VBNET.ATG"
out attribute);
-#line 2852 "VBNET.ATG"
+#line 2850 "VBNET.ATG"
attributes.Add(attribute);
while (
-#line 2853 "VBNET.ATG"
+#line 2851 "VBNET.ATG"
NotFinalComma()) {
Expect(22);
Attribute(
-#line 2853 "VBNET.ATG"
+#line 2851 "VBNET.ATG"
out attribute);
-#line 2853 "VBNET.ATG"
+#line 2851 "VBNET.ATG"
attributes.Add(attribute);
}
if (la.kind == 22) {
@@ -485,7 +486,7 @@ out attribute);
}
Expect(39);
-#line 2857 "VBNET.ATG"
+#line 2855 "VBNET.ATG"
section = new AttributeSection {
AttributeTarget = attributeTarget,
Attributes = attributes,
@@ -496,92 +497,92 @@ out attribute);
}
void TypeModifier(
-#line 3596 "VBNET.ATG"
+#line 3594 "VBNET.ATG"
ModifierList m) {
switch (la.kind) {
case 188: {
lexer.NextToken();
-#line 3597 "VBNET.ATG"
+#line 3595 "VBNET.ATG"
m.Add(Modifiers.Public, t.Location);
break;
}
case 187: {
lexer.NextToken();
-#line 3598 "VBNET.ATG"
+#line 3596 "VBNET.ATG"
m.Add(Modifiers.Protected, t.Location);
break;
}
case 125: {
lexer.NextToken();
-#line 3599 "VBNET.ATG"
+#line 3597 "VBNET.ATG"
m.Add(Modifiers.Internal, t.Location);
break;
}
case 185: {
lexer.NextToken();
-#line 3600 "VBNET.ATG"
+#line 3598 "VBNET.ATG"
m.Add(Modifiers.Private, t.Location);
break;
}
case 200: {
lexer.NextToken();
-#line 3601 "VBNET.ATG"
+#line 3599 "VBNET.ATG"
m.Add(Modifiers.Static, t.Location);
break;
}
case 199: {
lexer.NextToken();
-#line 3602 "VBNET.ATG"
+#line 3600 "VBNET.ATG"
m.Add(Modifiers.New, t.Location);
break;
}
case 156: {
lexer.NextToken();
-#line 3603 "VBNET.ATG"
+#line 3601 "VBNET.ATG"
m.Add(Modifiers.Abstract, t.Location);
break;
}
case 166: {
lexer.NextToken();
-#line 3604 "VBNET.ATG"
+#line 3602 "VBNET.ATG"
m.Add(Modifiers.Sealed, t.Location);
break;
}
case 183: {
lexer.NextToken();
-#line 3605 "VBNET.ATG"
+#line 3603 "VBNET.ATG"
m.Add(Modifiers.Partial, t.Location);
break;
}
- default: SynErr(248); break;
+ default: SynErr(249); break;
}
}
void NonModuleDeclaration(
-#line 447 "VBNET.ATG"
+#line 445 "VBNET.ATG"
ModifierList m, List attributes) {
-#line 449 "VBNET.ATG"
+#line 447 "VBNET.ATG"
TypeReference typeRef = null;
List baseInterfaces = null;
switch (la.kind) {
case 84: {
-#line 452 "VBNET.ATG"
+#line 450 "VBNET.ATG"
m.Check(Modifiers.Classes);
lexer.NextToken();
-#line 455 "VBNET.ATG"
+#line 453 "VBNET.ATG"
TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
newType.StartLocation = t.Location;
AddChild(newType);
@@ -591,42 +592,42 @@ ModifierList m, List attributes) {
Identifier();
-#line 462 "VBNET.ATG"
+#line 460 "VBNET.ATG"
newType.Name = t.val;
TypeParameterList(
-#line 463 "VBNET.ATG"
+#line 461 "VBNET.ATG"
newType.Templates);
EndOfStmt();
-#line 465 "VBNET.ATG"
+#line 463 "VBNET.ATG"
newType.BodyStartLocation = t.Location;
if (la.kind == 140) {
ClassBaseType(
-#line 466 "VBNET.ATG"
+#line 464 "VBNET.ATG"
out typeRef);
-#line 466 "VBNET.ATG"
+#line 464 "VBNET.ATG"
SafeAdd(newType, newType.BaseTypes, typeRef);
}
while (la.kind == 136) {
TypeImplementsClause(
-#line 467 "VBNET.ATG"
+#line 465 "VBNET.ATG"
out baseInterfaces);
-#line 467 "VBNET.ATG"
+#line 465 "VBNET.ATG"
newType.BaseTypes.AddRange(baseInterfaces);
}
ClassBody(
-#line 468 "VBNET.ATG"
+#line 466 "VBNET.ATG"
newType);
Expect(113);
Expect(84);
-#line 469 "VBNET.ATG"
+#line 467 "VBNET.ATG"
newType.EndLocation = t.EndLocation;
EndOfStmt();
-#line 472 "VBNET.ATG"
+#line 470 "VBNET.ATG"
BlockEnd();
break;
@@ -634,7 +635,7 @@ newType);
case 155: {
lexer.NextToken();
-#line 476 "VBNET.ATG"
+#line 474 "VBNET.ATG"
m.Check(Modifiers.VBModules);
TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
AddChild(newType);
@@ -644,17 +645,17 @@ newType);
Identifier();
-#line 483 "VBNET.ATG"
+#line 481 "VBNET.ATG"
newType.Name = t.val;
EndOfStmt();
-#line 485 "VBNET.ATG"
+#line 483 "VBNET.ATG"
newType.BodyStartLocation = t.Location;
ModuleBody(
-#line 486 "VBNET.ATG"
+#line 484 "VBNET.ATG"
newType);
-#line 488 "VBNET.ATG"
+#line 486 "VBNET.ATG"
BlockEnd();
break;
@@ -662,7 +663,7 @@ newType);
case 209: {
lexer.NextToken();
-#line 492 "VBNET.ATG"
+#line 490 "VBNET.ATG"
m.Check(Modifiers.VBStructures);
TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
AddChild(newType);
@@ -672,28 +673,28 @@ newType);
Identifier();
-#line 499 "VBNET.ATG"
+#line 497 "VBNET.ATG"
newType.Name = t.val;
TypeParameterList(
-#line 500 "VBNET.ATG"
+#line 498 "VBNET.ATG"
newType.Templates);
EndOfStmt();
-#line 502 "VBNET.ATG"
+#line 500 "VBNET.ATG"
newType.BodyStartLocation = t.Location;
while (la.kind == 136) {
TypeImplementsClause(
-#line 503 "VBNET.ATG"
+#line 501 "VBNET.ATG"
out baseInterfaces);
-#line 503 "VBNET.ATG"
+#line 501 "VBNET.ATG"
newType.BaseTypes.AddRange(baseInterfaces);
}
StructureBody(
-#line 504 "VBNET.ATG"
+#line 502 "VBNET.ATG"
newType);
-#line 506 "VBNET.ATG"
+#line 504 "VBNET.ATG"
BlockEnd();
break;
@@ -701,7 +702,7 @@ newType);
case 115: {
lexer.NextToken();
-#line 511 "VBNET.ATG"
+#line 509 "VBNET.ATG"
m.Check(Modifiers.VBEnums);
TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
newType.StartLocation = m.GetDeclarationLocation(t.Location);
@@ -712,26 +713,26 @@ newType);
Identifier();
-#line 519 "VBNET.ATG"
+#line 517 "VBNET.ATG"
newType.Name = t.val;
if (la.kind == 63) {
lexer.NextToken();
NonArrayTypeName(
-#line 520 "VBNET.ATG"
+#line 518 "VBNET.ATG"
out typeRef, false);
-#line 520 "VBNET.ATG"
+#line 518 "VBNET.ATG"
SafeAdd(newType, newType.BaseTypes, typeRef);
}
EndOfStmt();
-#line 522 "VBNET.ATG"
+#line 520 "VBNET.ATG"
newType.BodyStartLocation = t.Location;
EnumBody(
-#line 523 "VBNET.ATG"
+#line 521 "VBNET.ATG"
newType);
-#line 525 "VBNET.ATG"
+#line 523 "VBNET.ATG"
BlockEnd();
break;
@@ -739,7 +740,7 @@ newType);
case 142: {
lexer.NextToken();
-#line 530 "VBNET.ATG"
+#line 528 "VBNET.ATG"
m.Check(Modifiers.VBInterfacs);
TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
newType.StartLocation = m.GetDeclarationLocation(t.Location);
@@ -749,28 +750,28 @@ newType);
Identifier();
-#line 537 "VBNET.ATG"
+#line 535 "VBNET.ATG"
newType.Name = t.val;
TypeParameterList(
-#line 538 "VBNET.ATG"
+#line 536 "VBNET.ATG"
newType.Templates);
EndOfStmt();
-#line 540 "VBNET.ATG"
+#line 538 "VBNET.ATG"
newType.BodyStartLocation = t.Location;
while (la.kind == 140) {
InterfaceBase(
-#line 541 "VBNET.ATG"
+#line 539 "VBNET.ATG"
out baseInterfaces);
-#line 541 "VBNET.ATG"
+#line 539 "VBNET.ATG"
newType.BaseTypes.AddRange(baseInterfaces);
}
InterfaceBody(
-#line 542 "VBNET.ATG"
+#line 540 "VBNET.ATG"
newType);
-#line 544 "VBNET.ATG"
+#line 542 "VBNET.ATG"
BlockEnd();
break;
@@ -778,7 +779,7 @@ newType);
case 103: {
lexer.NextToken();
-#line 549 "VBNET.ATG"
+#line 547 "VBNET.ATG"
m.Check(Modifiers.VBDelegates);
DelegateDeclaration delegateDeclr = new DelegateDeclaration(m.Modifier, attributes);
delegateDeclr.ReturnType = new TypeReference("System.Void", true);
@@ -789,97 +790,97 @@ newType);
lexer.NextToken();
Identifier();
-#line 556 "VBNET.ATG"
+#line 554 "VBNET.ATG"
delegateDeclr.Name = t.val;
TypeParameterList(
-#line 557 "VBNET.ATG"
+#line 555 "VBNET.ATG"
delegateDeclr.Templates);
if (la.kind == 37) {
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 558 "VBNET.ATG"
+#line 556 "VBNET.ATG"
p);
}
Expect(38);
-#line 558 "VBNET.ATG"
+#line 556 "VBNET.ATG"
delegateDeclr.Parameters = p;
}
} else if (la.kind == 127) {
lexer.NextToken();
Identifier();
-#line 560 "VBNET.ATG"
+#line 558 "VBNET.ATG"
delegateDeclr.Name = t.val;
TypeParameterList(
-#line 561 "VBNET.ATG"
+#line 559 "VBNET.ATG"
delegateDeclr.Templates);
if (la.kind == 37) {
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 562 "VBNET.ATG"
+#line 560 "VBNET.ATG"
p);
}
Expect(38);
-#line 562 "VBNET.ATG"
+#line 560 "VBNET.ATG"
delegateDeclr.Parameters = p;
}
if (la.kind == 63) {
lexer.NextToken();
-#line 563 "VBNET.ATG"
+#line 561 "VBNET.ATG"
TypeReference type;
TypeName(
-#line 563 "VBNET.ATG"
+#line 561 "VBNET.ATG"
out type);
-#line 563 "VBNET.ATG"
+#line 561 "VBNET.ATG"
delegateDeclr.ReturnType = type;
}
- } else SynErr(249);
+ } else SynErr(250);
-#line 565 "VBNET.ATG"
+#line 563 "VBNET.ATG"
delegateDeclr.EndLocation = t.EndLocation;
EndOfStmt();
-#line 568 "VBNET.ATG"
+#line 566 "VBNET.ATG"
AddChild(delegateDeclr);
break;
}
- default: SynErr(250); break;
+ default: SynErr(251); break;
}
}
void TypeParameterList(
-#line 390 "VBNET.ATG"
+#line 388 "VBNET.ATG"
List templates) {
-#line 392 "VBNET.ATG"
+#line 390 "VBNET.ATG"
TemplateDefinition template;
if (
-#line 396 "VBNET.ATG"
+#line 394 "VBNET.ATG"
la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
lexer.NextToken();
Expect(169);
TypeParameter(
-#line 397 "VBNET.ATG"
+#line 395 "VBNET.ATG"
out template);
-#line 399 "VBNET.ATG"
+#line 397 "VBNET.ATG"
if (template != null) templates.Add(template);
while (la.kind == 22) {
lexer.NextToken();
TypeParameter(
-#line 402 "VBNET.ATG"
+#line 400 "VBNET.ATG"
out template);
-#line 404 "VBNET.ATG"
+#line 402 "VBNET.ATG"
if (template != null) templates.Add(template);
}
@@ -888,171 +889,171 @@ out template);
}
void TypeParameter(
-#line 412 "VBNET.ATG"
+#line 410 "VBNET.ATG"
out TemplateDefinition template) {
-#line 413 "VBNET.ATG"
+#line 411 "VBNET.ATG"
VarianceModifier modifier = VarianceModifier.Invariant;
if (la.kind == 138 || la.kind == 178) {
if (la.kind == 138) {
lexer.NextToken();
-#line 415 "VBNET.ATG"
+#line 413 "VBNET.ATG"
modifier = VarianceModifier.Contravariant;
} else {
lexer.NextToken();
-#line 415 "VBNET.ATG"
+#line 413 "VBNET.ATG"
modifier = VarianceModifier.Covariant;
}
}
Identifier();
-#line 415 "VBNET.ATG"
+#line 413 "VBNET.ATG"
template = new TemplateDefinition(t.val, null) { VarianceModifier = modifier };
if (la.kind == 63) {
TypeParameterConstraints(
-#line 416 "VBNET.ATG"
+#line 414 "VBNET.ATG"
template);
}
}
void TypeParameterConstraints(
-#line 420 "VBNET.ATG"
+#line 418 "VBNET.ATG"
TemplateDefinition template) {
-#line 422 "VBNET.ATG"
+#line 420 "VBNET.ATG"
TypeReference constraint;
Expect(63);
if (la.kind == 35) {
lexer.NextToken();
TypeParameterConstraint(
-#line 428 "VBNET.ATG"
+#line 426 "VBNET.ATG"
out constraint);
-#line 428 "VBNET.ATG"
+#line 426 "VBNET.ATG"
if (constraint != null) { template.Bases.Add(constraint); }
while (la.kind == 22) {
lexer.NextToken();
TypeParameterConstraint(
-#line 431 "VBNET.ATG"
+#line 429 "VBNET.ATG"
out constraint);
-#line 431 "VBNET.ATG"
+#line 429 "VBNET.ATG"
if (constraint != null) { template.Bases.Add(constraint); }
}
Expect(36);
} else if (StartOf(7)) {
TypeParameterConstraint(
-#line 434 "VBNET.ATG"
+#line 432 "VBNET.ATG"
out constraint);
-#line 434 "VBNET.ATG"
+#line 432 "VBNET.ATG"
if (constraint != null) { template.Bases.Add(constraint); }
- } else SynErr(251);
+ } else SynErr(252);
}
void TypeParameterConstraint(
-#line 438 "VBNET.ATG"
+#line 436 "VBNET.ATG"
out TypeReference constraint) {
-#line 439 "VBNET.ATG"
+#line 437 "VBNET.ATG"
constraint = null;
if (la.kind == 84) {
lexer.NextToken();
-#line 440 "VBNET.ATG"
+#line 438 "VBNET.ATG"
constraint = TypeReference.ClassConstraint;
} else if (la.kind == 209) {
lexer.NextToken();
-#line 441 "VBNET.ATG"
+#line 439 "VBNET.ATG"
constraint = TypeReference.StructConstraint;
} else if (la.kind == 162) {
lexer.NextToken();
-#line 442 "VBNET.ATG"
+#line 440 "VBNET.ATG"
constraint = TypeReference.NewConstraint;
} else if (StartOf(8)) {
TypeName(
-#line 443 "VBNET.ATG"
+#line 441 "VBNET.ATG"
out constraint);
- } else SynErr(252);
+ } else SynErr(253);
}
void ClassBaseType(
-#line 788 "VBNET.ATG"
+#line 786 "VBNET.ATG"
out TypeReference typeRef) {
-#line 790 "VBNET.ATG"
+#line 788 "VBNET.ATG"
typeRef = null;
Expect(140);
TypeName(
-#line 793 "VBNET.ATG"
+#line 791 "VBNET.ATG"
out typeRef);
EndOfStmt();
}
void TypeImplementsClause(
-#line 1605 "VBNET.ATG"
+#line 1603 "VBNET.ATG"
out List baseInterfaces) {
-#line 1607 "VBNET.ATG"
+#line 1605 "VBNET.ATG"
baseInterfaces = new List();
TypeReference type = null;
Expect(136);
TypeName(
-#line 1610 "VBNET.ATG"
+#line 1608 "VBNET.ATG"
out type);
-#line 1612 "VBNET.ATG"
+#line 1610 "VBNET.ATG"
if (type != null) baseInterfaces.Add(type);
while (la.kind == 22) {
lexer.NextToken();
TypeName(
-#line 1615 "VBNET.ATG"
+#line 1613 "VBNET.ATG"
out type);
-#line 1616 "VBNET.ATG"
+#line 1614 "VBNET.ATG"
if (type != null) baseInterfaces.Add(type);
}
EndOfStmt();
}
void ClassBody(
-#line 582 "VBNET.ATG"
+#line 580 "VBNET.ATG"
TypeDeclaration newType) {
-#line 583 "VBNET.ATG"
+#line 581 "VBNET.ATG"
AttributeSection section;
while (la.kind == 1 || la.kind == 21) {
EndOfStmt();
}
while (StartOf(9)) {
-#line 586 "VBNET.ATG"
+#line 584 "VBNET.ATG"
List attributes = new List();
ModifierList m = new ModifierList();
while (la.kind == 40) {
AttributeSection(
-#line 589 "VBNET.ATG"
+#line 587 "VBNET.ATG"
out section);
-#line 589 "VBNET.ATG"
+#line 587 "VBNET.ATG"
attributes.Add(section);
}
while (StartOf(10)) {
MemberModifier(
-#line 590 "VBNET.ATG"
+#line 588 "VBNET.ATG"
m);
}
ClassMemberDecl(
-#line 591 "VBNET.ATG"
+#line 589 "VBNET.ATG"
m, attributes);
while (la.kind == 1 || la.kind == 21) {
EndOfStmt();
@@ -1061,35 +1062,35 @@ m, attributes);
}
void ModuleBody(
-#line 613 "VBNET.ATG"
+#line 611 "VBNET.ATG"
TypeDeclaration newType) {
-#line 614 "VBNET.ATG"
+#line 612 "VBNET.ATG"
AttributeSection section;
while (la.kind == 1 || la.kind == 21) {
EndOfStmt();
}
while (StartOf(9)) {
-#line 617 "VBNET.ATG"
+#line 615 "VBNET.ATG"
List attributes = new List();
ModifierList m = new ModifierList();
while (la.kind == 40) {
AttributeSection(
-#line 620 "VBNET.ATG"
+#line 618 "VBNET.ATG"
out section);
-#line 620 "VBNET.ATG"
+#line 618 "VBNET.ATG"
attributes.Add(section);
}
while (StartOf(10)) {
MemberModifier(
-#line 621 "VBNET.ATG"
+#line 619 "VBNET.ATG"
m);
}
ClassMemberDecl(
-#line 622 "VBNET.ATG"
+#line 620 "VBNET.ATG"
m, attributes);
while (la.kind == 1 || la.kind == 21) {
EndOfStmt();
@@ -1098,41 +1099,41 @@ m, attributes);
Expect(113);
Expect(155);
-#line 625 "VBNET.ATG"
+#line 623 "VBNET.ATG"
newType.EndLocation = t.EndLocation;
EndOfStmt();
}
void StructureBody(
-#line 596 "VBNET.ATG"
+#line 594 "VBNET.ATG"
TypeDeclaration newType) {
-#line 597 "VBNET.ATG"
+#line 595 "VBNET.ATG"
AttributeSection section;
while (la.kind == 1 || la.kind == 21) {
EndOfStmt();
}
while (StartOf(9)) {
-#line 600 "VBNET.ATG"
+#line 598 "VBNET.ATG"
List attributes = new List();
ModifierList m = new ModifierList();
while (la.kind == 40) {
AttributeSection(
-#line 603 "VBNET.ATG"
+#line 601 "VBNET.ATG"
out section);
-#line 603 "VBNET.ATG"
+#line 601 "VBNET.ATG"
attributes.Add(section);
}
while (StartOf(10)) {
MemberModifier(
-#line 604 "VBNET.ATG"
+#line 602 "VBNET.ATG"
m);
}
StructureMemberDecl(
-#line 605 "VBNET.ATG"
+#line 603 "VBNET.ATG"
m, attributes);
while (la.kind == 1 || la.kind == 21) {
EndOfStmt();
@@ -1141,16 +1142,16 @@ m, attributes);
Expect(113);
Expect(209);
-#line 608 "VBNET.ATG"
+#line 606 "VBNET.ATG"
newType.EndLocation = t.EndLocation;
EndOfStmt();
}
void NonArrayTypeName(
-#line 2654 "VBNET.ATG"
+#line 2652 "VBNET.ATG"
out TypeReference typeref, bool canBeUnbound) {
-#line 2656 "VBNET.ATG"
+#line 2654 "VBNET.ATG"
string name;
typeref = null;
bool isGlobal = false;
@@ -1160,36 +1161,36 @@ out TypeReference typeref, bool canBeUnbound) {
lexer.NextToken();
Expect(26);
-#line 2661 "VBNET.ATG"
+#line 2659 "VBNET.ATG"
isGlobal = true;
}
QualIdentAndTypeArguments(
-#line 2662 "VBNET.ATG"
+#line 2660 "VBNET.ATG"
out typeref, canBeUnbound);
-#line 2663 "VBNET.ATG"
+#line 2661 "VBNET.ATG"
typeref.IsGlobal = isGlobal;
while (la.kind == 26) {
lexer.NextToken();
-#line 2664 "VBNET.ATG"
+#line 2662 "VBNET.ATG"
TypeReference nestedTypeRef;
QualIdentAndTypeArguments(
-#line 2665 "VBNET.ATG"
+#line 2663 "VBNET.ATG"
out nestedTypeRef, canBeUnbound);
-#line 2666 "VBNET.ATG"
+#line 2664 "VBNET.ATG"
typeref = new InnerClassTypeReference(typeref, nestedTypeRef.Type, nestedTypeRef.GenericTypes);
}
} else if (la.kind == 168) {
lexer.NextToken();
-#line 2669 "VBNET.ATG"
+#line 2667 "VBNET.ATG"
typeref = new TypeReference("System.Object", true);
if (la.kind == 33) {
lexer.NextToken();
-#line 2673 "VBNET.ATG"
+#line 2671 "VBNET.ATG"
List typeArguments = new List(1);
if (typeref != null) typeArguments.Add(typeref);
typeref = new TypeReference("System.Nullable", typeArguments) { IsKeyword = true };
@@ -1197,38 +1198,38 @@ out nestedTypeRef, canBeUnbound);
}
} else if (StartOf(12)) {
PrimitiveTypeName(
-#line 2679 "VBNET.ATG"
+#line 2677 "VBNET.ATG"
out name);
-#line 2679 "VBNET.ATG"
+#line 2677 "VBNET.ATG"
typeref = new TypeReference(name, true);
if (la.kind == 33) {
lexer.NextToken();
-#line 2683 "VBNET.ATG"
+#line 2681 "VBNET.ATG"
List typeArguments = new List(1);
if (typeref != null) typeArguments.Add(typeref);
typeref = new TypeReference("System.Nullable", typeArguments) { IsKeyword = true };
}
- } else SynErr(253);
+ } else SynErr(254);
}
void EnumBody(
-#line 629 "VBNET.ATG"
+#line 627 "VBNET.ATG"
TypeDeclaration newType) {
-#line 630 "VBNET.ATG"
+#line 628 "VBNET.ATG"
FieldDeclaration f;
while (la.kind == 1 || la.kind == 21) {
EndOfStmt();
}
while (StartOf(13)) {
EnumMemberDecl(
-#line 633 "VBNET.ATG"
+#line 631 "VBNET.ATG"
out f);
-#line 635 "VBNET.ATG"
+#line 633 "VBNET.ATG"
AddChild(f);
while (la.kind == 1 || la.kind == 21) {
@@ -1238,40 +1239,40 @@ out f);
Expect(113);
Expect(115);
-#line 639 "VBNET.ATG"
+#line 637 "VBNET.ATG"
newType.EndLocation = t.EndLocation;
EndOfStmt();
}
void InterfaceBase(
-#line 1590 "VBNET.ATG"
+#line 1588 "VBNET.ATG"
out List bases) {
-#line 1592 "VBNET.ATG"
+#line 1590 "VBNET.ATG"
TypeReference type;
bases = new List();
Expect(140);
TypeName(
-#line 1596 "VBNET.ATG"
+#line 1594 "VBNET.ATG"
out type);
-#line 1596 "VBNET.ATG"
+#line 1594 "VBNET.ATG"
if (type != null) bases.Add(type);
while (la.kind == 22) {
lexer.NextToken();
TypeName(
-#line 1599 "VBNET.ATG"
+#line 1597 "VBNET.ATG"
out type);
-#line 1599 "VBNET.ATG"
+#line 1597 "VBNET.ATG"
if (type != null) bases.Add(type);
}
EndOfStmt();
}
void InterfaceBody(
-#line 643 "VBNET.ATG"
+#line 641 "VBNET.ATG"
TypeDeclaration newType) {
while (la.kind == 1 || la.kind == 21) {
EndOfStmt();
@@ -1285,188 +1286,188 @@ TypeDeclaration newType) {
Expect(113);
Expect(142);
-#line 649 "VBNET.ATG"
+#line 647 "VBNET.ATG"
newType.EndLocation = t.EndLocation;
EndOfStmt();
}
void FormalParameterList(
-#line 2867 "VBNET.ATG"
+#line 2865 "VBNET.ATG"
List parameter) {
-#line 2868 "VBNET.ATG"
+#line 2866 "VBNET.ATG"
ParameterDeclarationExpression p;
FormalParameter(
-#line 2870 "VBNET.ATG"
+#line 2868 "VBNET.ATG"
out p);
-#line 2870 "VBNET.ATG"
+#line 2868 "VBNET.ATG"
if (p != null) parameter.Add(p);
while (la.kind == 22) {
lexer.NextToken();
FormalParameter(
-#line 2872 "VBNET.ATG"
+#line 2870 "VBNET.ATG"
out p);
-#line 2872 "VBNET.ATG"
+#line 2870 "VBNET.ATG"
if (p != null) parameter.Add(p);
}
}
void MemberModifier(
-#line 3608 "VBNET.ATG"
+#line 3606 "VBNET.ATG"
ModifierList m) {
switch (la.kind) {
case 156: {
lexer.NextToken();
-#line 3609 "VBNET.ATG"
+#line 3607 "VBNET.ATG"
m.Add(Modifiers.Abstract, t.Location);
break;
}
case 102: {
lexer.NextToken();
-#line 3610 "VBNET.ATG"
+#line 3608 "VBNET.ATG"
m.Add(Modifiers.Default, t.Location);
break;
}
case 125: {
lexer.NextToken();
-#line 3611 "VBNET.ATG"
+#line 3609 "VBNET.ATG"
m.Add(Modifiers.Internal, t.Location);
break;
}
case 199: {
lexer.NextToken();
-#line 3612 "VBNET.ATG"
+#line 3610 "VBNET.ATG"
m.Add(Modifiers.New, t.Location);
break;
}
case 181: {
lexer.NextToken();
-#line 3613 "VBNET.ATG"
+#line 3611 "VBNET.ATG"
m.Add(Modifiers.Override, t.Location);
break;
}
case 157: {
lexer.NextToken();
-#line 3614 "VBNET.ATG"
+#line 3612 "VBNET.ATG"
m.Add(Modifiers.Abstract, t.Location);
break;
}
case 185: {
lexer.NextToken();
-#line 3615 "VBNET.ATG"
+#line 3613 "VBNET.ATG"
m.Add(Modifiers.Private, t.Location);
break;
}
case 187: {
lexer.NextToken();
-#line 3616 "VBNET.ATG"
+#line 3614 "VBNET.ATG"
m.Add(Modifiers.Protected, t.Location);
break;
}
case 188: {
lexer.NextToken();
-#line 3617 "VBNET.ATG"
+#line 3615 "VBNET.ATG"
m.Add(Modifiers.Public, t.Location);
break;
}
case 166: {
lexer.NextToken();
-#line 3618 "VBNET.ATG"
+#line 3616 "VBNET.ATG"
m.Add(Modifiers.Sealed, t.Location);
break;
}
case 167: {
lexer.NextToken();
-#line 3619 "VBNET.ATG"
+#line 3617 "VBNET.ATG"
m.Add(Modifiers.Sealed, t.Location);
break;
}
case 200: {
lexer.NextToken();
-#line 3620 "VBNET.ATG"
+#line 3618 "VBNET.ATG"
m.Add(Modifiers.Static, t.Location);
break;
}
case 180: {
lexer.NextToken();
-#line 3621 "VBNET.ATG"
+#line 3619 "VBNET.ATG"
m.Add(Modifiers.Virtual, t.Location);
break;
}
case 179: {
lexer.NextToken();
-#line 3622 "VBNET.ATG"
+#line 3620 "VBNET.ATG"
m.Add(Modifiers.Overloads, t.Location);
break;
}
case 190: {
lexer.NextToken();
-#line 3623 "VBNET.ATG"
+#line 3621 "VBNET.ATG"
m.Add(Modifiers.ReadOnly, t.Location);
break;
}
case 235: {
lexer.NextToken();
-#line 3624 "VBNET.ATG"
+#line 3622 "VBNET.ATG"
m.Add(Modifiers.WriteOnly, t.Location);
break;
}
case 234: {
lexer.NextToken();
-#line 3625 "VBNET.ATG"
+#line 3623 "VBNET.ATG"
m.Add(Modifiers.WithEvents, t.Location);
break;
}
case 105: {
lexer.NextToken();
-#line 3626 "VBNET.ATG"
+#line 3624 "VBNET.ATG"
m.Add(Modifiers.Dim, t.Location);
break;
}
case 183: {
lexer.NextToken();
-#line 3627 "VBNET.ATG"
+#line 3625 "VBNET.ATG"
m.Add(Modifiers.Partial, t.Location);
break;
}
- default: SynErr(254); break;
+ default: SynErr(255); break;
}
}
void ClassMemberDecl(
-#line 784 "VBNET.ATG"
+#line 782 "VBNET.ATG"
ModifierList m, List attributes) {
StructureMemberDecl(
-#line 785 "VBNET.ATG"
+#line 783 "VBNET.ATG"
m, attributes);
}
void StructureMemberDecl(
-#line 798 "VBNET.ATG"
+#line 796 "VBNET.ATG"
ModifierList m, List attributes) {
-#line 800 "VBNET.ATG"
+#line 798 "VBNET.ATG"
TypeReference type = null;
List p = new List();
Statement stmt = null;
@@ -1476,37 +1477,37 @@ ModifierList m, List attributes) {
switch (la.kind) {
case 84: case 103: case 115: case 142: case 155: case 209: {
NonModuleDeclaration(
-#line 807 "VBNET.ATG"
+#line 805 "VBNET.ATG"
m, attributes);
break;
}
case 210: {
lexer.NextToken();
-#line 811 "VBNET.ATG"
+#line 809 "VBNET.ATG"
Location startPos = t.Location;
if (StartOf(4)) {
-#line 815 "VBNET.ATG"
+#line 813 "VBNET.ATG"
string name = String.Empty;
MethodDeclaration methodDeclaration; List handlesClause = null;
List implementsClause = null;
Identifier();
-#line 821 "VBNET.ATG"
+#line 819 "VBNET.ATG"
name = t.val;
m.Check(Modifiers.VBMethods);
TypeParameterList(
-#line 824 "VBNET.ATG"
+#line 822 "VBNET.ATG"
templates);
if (la.kind == 37) {
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 825 "VBNET.ATG"
+#line 823 "VBNET.ATG"
p);
}
Expect(38);
@@ -1514,23 +1515,23 @@ p);
if (la.kind == 134 || la.kind == 136) {
if (la.kind == 136) {
ImplementsClause(
-#line 828 "VBNET.ATG"
+#line 826 "VBNET.ATG"
out implementsClause);
} else {
HandlesClause(
-#line 830 "VBNET.ATG"
+#line 828 "VBNET.ATG"
out handlesClause);
}
}
-#line 833 "VBNET.ATG"
+#line 831 "VBNET.ATG"
Location endLocation = t.EndLocation;
if (
-#line 836 "VBNET.ATG"
+#line 834 "VBNET.ATG"
IsMustOverride(m)) {
EndOfStmt();
-#line 839 "VBNET.ATG"
+#line 837 "VBNET.ATG"
methodDeclaration = new MethodDeclaration {
Name = name, Modifier = m.Modifier, Parameters = p, Attributes = attributes,
StartLocation = m.GetDeclarationLocation(startPos), EndLocation = endLocation,
@@ -1544,7 +1545,7 @@ IsMustOverride(m)) {
} else if (la.kind == 1) {
lexer.NextToken();
-#line 852 "VBNET.ATG"
+#line 850 "VBNET.ATG"
methodDeclaration = new MethodDeclaration {
Name = name, Modifier = m.Modifier, Parameters = p, Attributes = attributes,
StartLocation = m.GetDeclarationLocation(startPos), EndLocation = endLocation,
@@ -1556,67 +1557,67 @@ IsMustOverride(m)) {
AddChild(methodDeclaration);
-#line 863 "VBNET.ATG"
+#line 861 "VBNET.ATG"
if (ParseMethodBodies) {
Block(
-#line 864 "VBNET.ATG"
+#line 862 "VBNET.ATG"
out stmt);
Expect(113);
Expect(210);
-#line 866 "VBNET.ATG"
+#line 864 "VBNET.ATG"
} else {
// don't parse method body
lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
}
-#line 872 "VBNET.ATG"
+#line 870 "VBNET.ATG"
methodDeclaration.Body = (BlockStatement)stmt;
-#line 873 "VBNET.ATG"
+#line 871 "VBNET.ATG"
methodDeclaration.Body.EndLocation = t.EndLocation;
EndOfStmt();
- } else SynErr(255);
+ } else SynErr(256);
} else if (la.kind == 162) {
lexer.NextToken();
if (la.kind == 37) {
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 877 "VBNET.ATG"
+#line 875 "VBNET.ATG"
p);
}
Expect(38);
}
-#line 878 "VBNET.ATG"
+#line 876 "VBNET.ATG"
m.Check(Modifiers.Constructors);
-#line 879 "VBNET.ATG"
+#line 877 "VBNET.ATG"
Location constructorEndLocation = t.EndLocation;
Expect(1);
-#line 882 "VBNET.ATG"
+#line 880 "VBNET.ATG"
if (ParseMethodBodies) {
Block(
-#line 883 "VBNET.ATG"
+#line 881 "VBNET.ATG"
out stmt);
Expect(113);
Expect(210);
-#line 885 "VBNET.ATG"
+#line 883 "VBNET.ATG"
} else {
// don't parse method body
lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
}
-#line 891 "VBNET.ATG"
+#line 889 "VBNET.ATG"
Location endLocation = t.EndLocation;
EndOfStmt();
-#line 894 "VBNET.ATG"
+#line 892 "VBNET.ATG"
ConstructorDeclaration cd = new ConstructorDeclaration("New", m.Modifier, p, attributes);
cd.StartLocation = m.GetDeclarationLocation(startPos);
cd.EndLocation = constructorEndLocation;
@@ -1624,13 +1625,13 @@ out stmt);
cd.Body.EndLocation = endLocation;
AddChild(cd);
- } else SynErr(256);
+ } else SynErr(257);
break;
}
case 127: {
lexer.NextToken();
-#line 906 "VBNET.ATG"
+#line 904 "VBNET.ATG"
m.Check(Modifiers.VBMethods);
string name = String.Empty;
Location startPos = t.Location;
@@ -1640,16 +1641,16 @@ out stmt);
Identifier();
-#line 913 "VBNET.ATG"
+#line 911 "VBNET.ATG"
name = t.val;
TypeParameterList(
-#line 914 "VBNET.ATG"
+#line 912 "VBNET.ATG"
templates);
if (la.kind == 37) {
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 915 "VBNET.ATG"
+#line 913 "VBNET.ATG"
p);
}
Expect(38);
@@ -1658,10 +1659,10 @@ p);
lexer.NextToken();
while (la.kind == 40) {
AttributeSection(
-#line 917 "VBNET.ATG"
+#line 915 "VBNET.ATG"
out returnTypeAttributeSection);
-#line 919 "VBNET.ATG"
+#line 917 "VBNET.ATG"
if (returnTypeAttributeSection != null) {
returnTypeAttributeSection.AttributeTarget = "return";
attributes.Add(returnTypeAttributeSection);
@@ -1669,11 +1670,11 @@ out returnTypeAttributeSection);
}
TypeName(
-#line 925 "VBNET.ATG"
+#line 923 "VBNET.ATG"
out type);
}
-#line 927 "VBNET.ATG"
+#line 925 "VBNET.ATG"
if(type == null) {
type = new TypeReference("System.Object", true);
}
@@ -1681,23 +1682,23 @@ out type);
if (la.kind == 134 || la.kind == 136) {
if (la.kind == 136) {
ImplementsClause(
-#line 933 "VBNET.ATG"
+#line 931 "VBNET.ATG"
out implementsClause);
} else {
HandlesClause(
-#line 935 "VBNET.ATG"
+#line 933 "VBNET.ATG"
out handlesClause);
}
}
-#line 938 "VBNET.ATG"
+#line 936 "VBNET.ATG"
Location endLocation = t.EndLocation;
if (
-#line 941 "VBNET.ATG"
+#line 939 "VBNET.ATG"
IsMustOverride(m)) {
EndOfStmt();
-#line 944 "VBNET.ATG"
+#line 942 "VBNET.ATG"
methodDeclaration = new MethodDeclaration {
Name = name, Modifier = m.Modifier, TypeReference = type,
Parameters = p, Attributes = attributes,
@@ -1713,7 +1714,7 @@ IsMustOverride(m)) {
} else if (la.kind == 1) {
lexer.NextToken();
-#line 959 "VBNET.ATG"
+#line 957 "VBNET.ATG"
methodDeclaration = new MethodDeclaration {
Name = name, Modifier = m.Modifier, TypeReference = type,
Parameters = p, Attributes = attributes,
@@ -1728,12 +1729,12 @@ IsMustOverride(m)) {
if (ParseMethodBodies) {
Block(
-#line 972 "VBNET.ATG"
+#line 970 "VBNET.ATG"
out stmt);
Expect(113);
Expect(127);
-#line 974 "VBNET.ATG"
+#line 972 "VBNET.ATG"
} else {
// don't parse method body
lexer.SkipCurrentBlock(Tokens.Function); stmt = new BlockStatement();
@@ -1743,13 +1744,13 @@ out stmt);
methodDeclaration.Body.EndLocation = t.EndLocation;
EndOfStmt();
- } else SynErr(257);
+ } else SynErr(258);
break;
}
case 101: {
lexer.NextToken();
-#line 988 "VBNET.ATG"
+#line 986 "VBNET.ATG"
m.Check(Modifiers.VBExternalMethods);
Location startPos = t.Location;
CharsetModifier charsetModifer = CharsetModifier.None;
@@ -1759,39 +1760,39 @@ out stmt);
if (StartOf(15)) {
Charset(
-#line 995 "VBNET.ATG"
+#line 993 "VBNET.ATG"
out charsetModifer);
}
if (la.kind == 210) {
lexer.NextToken();
Identifier();
-#line 998 "VBNET.ATG"
+#line 996 "VBNET.ATG"
name = t.val;
Expect(149);
Expect(3);
-#line 999 "VBNET.ATG"
+#line 997 "VBNET.ATG"
library = t.literalValue as string;
if (la.kind == 59) {
lexer.NextToken();
Expect(3);
-#line 1000 "VBNET.ATG"
+#line 998 "VBNET.ATG"
alias = t.literalValue as string;
}
if (la.kind == 37) {
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 1001 "VBNET.ATG"
+#line 999 "VBNET.ATG"
p);
}
Expect(38);
}
EndOfStmt();
-#line 1004 "VBNET.ATG"
+#line 1002 "VBNET.ATG"
DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, null, p, attributes, library, alias, charsetModifer);
declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
declareDeclaration.EndLocation = t.EndLocation;
@@ -1801,25 +1802,25 @@ p);
lexer.NextToken();
Identifier();
-#line 1011 "VBNET.ATG"
+#line 1009 "VBNET.ATG"
name = t.val;
Expect(149);
Expect(3);
-#line 1012 "VBNET.ATG"
+#line 1010 "VBNET.ATG"
library = t.literalValue as string;
if (la.kind == 59) {
lexer.NextToken();
Expect(3);
-#line 1013 "VBNET.ATG"
+#line 1011 "VBNET.ATG"
alias = t.literalValue as string;
}
if (la.kind == 37) {
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 1014 "VBNET.ATG"
+#line 1012 "VBNET.ATG"
p);
}
Expect(38);
@@ -1827,24 +1828,24 @@ p);
if (la.kind == 63) {
lexer.NextToken();
TypeName(
-#line 1015 "VBNET.ATG"
+#line 1013 "VBNET.ATG"
out type);
}
EndOfStmt();
-#line 1018 "VBNET.ATG"
+#line 1016 "VBNET.ATG"
DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, type, p, attributes, library, alias, charsetModifer);
declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
declareDeclaration.EndLocation = t.EndLocation;
AddChild(declareDeclaration);
- } else SynErr(258);
+ } else SynErr(259);
break;
}
case 119: {
lexer.NextToken();
-#line 1028 "VBNET.ATG"
+#line 1026 "VBNET.ATG"
m.Check(Modifiers.VBEvents);
Location startPos = t.Location;
EventDeclaration eventDeclaration;
@@ -1853,31 +1854,31 @@ out type);
Identifier();
-#line 1034 "VBNET.ATG"
+#line 1032 "VBNET.ATG"
name= t.val;
if (la.kind == 63) {
lexer.NextToken();
TypeName(
-#line 1036 "VBNET.ATG"
+#line 1034 "VBNET.ATG"
out type);
} else if (StartOf(16)) {
if (la.kind == 37) {
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 1038 "VBNET.ATG"
+#line 1036 "VBNET.ATG"
p);
}
Expect(38);
}
- } else SynErr(259);
+ } else SynErr(260);
if (la.kind == 136) {
ImplementsClause(
-#line 1040 "VBNET.ATG"
+#line 1038 "VBNET.ATG"
out implementsClause);
}
-#line 1042 "VBNET.ATG"
+#line 1040 "VBNET.ATG"
eventDeclaration = new EventDeclaration {
Name = name, TypeReference = type, Modifier = m.Modifier,
Parameters = p, Attributes = attributes, InterfaceImplementations = implementsClause,
@@ -1891,29 +1892,29 @@ out implementsClause);
}
case 2: case 58: case 62: case 64: case 65: case 66: case 67: case 70: case 87: case 104: case 107: case 116: case 121: case 126: case 133: case 139: case 143: case 146: case 147: case 170: case 176: case 178: case 184: case 203: case 212: case 213: case 223: case 224: case 230: {
-#line 1053 "VBNET.ATG"
+#line 1051 "VBNET.ATG"
m.Check(Modifiers.Fields);
FieldDeclaration fd = new FieldDeclaration(attributes, null, m.Modifier);
IdentifierForFieldDeclaration();
-#line 1056 "VBNET.ATG"
+#line 1054 "VBNET.ATG"
string name = t.val;
-#line 1057 "VBNET.ATG"
+#line 1055 "VBNET.ATG"
fd.StartLocation = m.GetDeclarationLocation(t.Location);
VariableDeclaratorPartAfterIdentifier(
-#line 1059 "VBNET.ATG"
+#line 1057 "VBNET.ATG"
variableDeclarators, name);
while (la.kind == 22) {
lexer.NextToken();
VariableDeclarator(
-#line 1060 "VBNET.ATG"
+#line 1058 "VBNET.ATG"
variableDeclarators);
}
EndOfStmt();
-#line 1063 "VBNET.ATG"
+#line 1061 "VBNET.ATG"
fd.EndLocation = t.EndLocation;
fd.Fields = variableDeclarators;
AddChild(fd);
@@ -1922,35 +1923,35 @@ variableDeclarators);
}
case 88: {
-#line 1068 "VBNET.ATG"
+#line 1066 "VBNET.ATG"
m.Check(Modifiers.Fields);
lexer.NextToken();
-#line 1069 "VBNET.ATG"
+#line 1067 "VBNET.ATG"
m.Add(Modifiers.Const, t.Location);
-#line 1071 "VBNET.ATG"
+#line 1069 "VBNET.ATG"
FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier);
fd.StartLocation = m.GetDeclarationLocation(t.Location);
List constantDeclarators = new List();
ConstantDeclarator(
-#line 1075 "VBNET.ATG"
+#line 1073 "VBNET.ATG"
constantDeclarators);
while (la.kind == 22) {
lexer.NextToken();
ConstantDeclarator(
-#line 1076 "VBNET.ATG"
+#line 1074 "VBNET.ATG"
constantDeclarators);
}
-#line 1078 "VBNET.ATG"
+#line 1076 "VBNET.ATG"
fd.Fields = constantDeclarators;
fd.EndLocation = t.Location;
EndOfStmt();
-#line 1083 "VBNET.ATG"
+#line 1081 "VBNET.ATG"
fd.EndLocation = t.EndLocation;
AddChild(fd);
@@ -1959,7 +1960,7 @@ constantDeclarators);
case 186: {
lexer.NextToken();
-#line 1089 "VBNET.ATG"
+#line 1087 "VBNET.ATG"
m.Check(Modifiers.VBProperties);
Location startPos = t.Location;
List implementsClause = null;
@@ -1968,13 +1969,13 @@ constantDeclarators);
Identifier();
-#line 1095 "VBNET.ATG"
+#line 1093 "VBNET.ATG"
string propertyName = t.val;
if (la.kind == 37) {
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 1096 "VBNET.ATG"
+#line 1094 "VBNET.ATG"
p);
}
Expect(38);
@@ -1983,10 +1984,10 @@ p);
lexer.NextToken();
while (la.kind == 40) {
AttributeSection(
-#line 1099 "VBNET.ATG"
+#line 1097 "VBNET.ATG"
out returnTypeAttributeSection);
-#line 1101 "VBNET.ATG"
+#line 1099 "VBNET.ATG"
if (returnTypeAttributeSection != null) {
returnTypeAttributeSection.AttributeTarget = "return";
attributes.Add(returnTypeAttributeSection);
@@ -1994,13 +1995,13 @@ out returnTypeAttributeSection);
}
if (
-#line 1108 "VBNET.ATG"
+#line 1106 "VBNET.ATG"
IsNewExpression()) {
ObjectCreateExpression(
-#line 1108 "VBNET.ATG"
+#line 1106 "VBNET.ATG"
out initializer);
-#line 1110 "VBNET.ATG"
+#line 1108 "VBNET.ATG"
if (initializer is ObjectCreateExpression) {
type = ((ObjectCreateExpression)initializer).CreateType.Clone();
} else {
@@ -2009,27 +2010,27 @@ out initializer);
} else if (StartOf(8)) {
TypeName(
-#line 1117 "VBNET.ATG"
+#line 1115 "VBNET.ATG"
out type);
- } else SynErr(260);
+ } else SynErr(261);
}
if (la.kind == 20) {
lexer.NextToken();
Expr(
-#line 1120 "VBNET.ATG"
+#line 1118 "VBNET.ATG"
out initializer);
}
if (la.kind == 136) {
ImplementsClause(
-#line 1121 "VBNET.ATG"
+#line 1119 "VBNET.ATG"
out implementsClause);
}
EndOfStmt();
if (
-#line 1125 "VBNET.ATG"
+#line 1123 "VBNET.ATG"
IsMustOverride(m) || IsAutomaticProperty()) {
-#line 1127 "VBNET.ATG"
+#line 1125 "VBNET.ATG"
PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
pDecl.StartLocation = m.GetDeclarationLocation(startPos);
pDecl.EndLocation = t.Location;
@@ -2042,7 +2043,7 @@ IsMustOverride(m) || IsAutomaticProperty()) {
} else if (StartOf(17)) {
-#line 1139 "VBNET.ATG"
+#line 1137 "VBNET.ATG"
PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
pDecl.StartLocation = m.GetDeclarationLocation(startPos);
pDecl.EndLocation = t.Location;
@@ -2054,29 +2055,29 @@ IsMustOverride(m) || IsAutomaticProperty()) {
PropertySetRegion setRegion;
AccessorDecls(
-#line 1149 "VBNET.ATG"
+#line 1147 "VBNET.ATG"
out getRegion, out setRegion);
Expect(113);
Expect(186);
EndOfStmt();
-#line 1153 "VBNET.ATG"
+#line 1151 "VBNET.ATG"
pDecl.GetRegion = getRegion;
pDecl.SetRegion = setRegion;
pDecl.BodyEnd = t.Location; // t = EndOfStmt; not "Property"
AddChild(pDecl);
- } else SynErr(261);
+ } else SynErr(262);
break;
}
case 98: {
lexer.NextToken();
-#line 1160 "VBNET.ATG"
+#line 1158 "VBNET.ATG"
Location startPos = t.Location;
Expect(119);
-#line 1162 "VBNET.ATG"
+#line 1160 "VBNET.ATG"
m.Check(Modifiers.VBCustomEvents);
EventAddRemoveRegion eventAccessorDeclaration;
EventAddRegion addHandlerAccessorDeclaration = null;
@@ -2086,24 +2087,24 @@ out getRegion, out setRegion);
Identifier();
-#line 1169 "VBNET.ATG"
+#line 1167 "VBNET.ATG"
string customEventName = t.val;
Expect(63);
TypeName(
-#line 1170 "VBNET.ATG"
+#line 1168 "VBNET.ATG"
out type);
if (la.kind == 136) {
ImplementsClause(
-#line 1171 "VBNET.ATG"
+#line 1169 "VBNET.ATG"
out implementsClause);
}
EndOfStmt();
while (StartOf(18)) {
EventAccessorDeclaration(
-#line 1174 "VBNET.ATG"
+#line 1172 "VBNET.ATG"
out eventAccessorDeclaration);
-#line 1176 "VBNET.ATG"
+#line 1174 "VBNET.ATG"
if(eventAccessorDeclaration is EventAddRegion)
{
addHandlerAccessorDeclaration = (EventAddRegion)eventAccessorDeclaration;
@@ -2122,7 +2123,7 @@ out eventAccessorDeclaration);
Expect(119);
EndOfStmt();
-#line 1192 "VBNET.ATG"
+#line 1190 "VBNET.ATG"
if(addHandlerAccessorDeclaration == null)
{
Error("Need to provide AddHandler accessor.");
@@ -2153,24 +2154,24 @@ out eventAccessorDeclaration);
}
case 161: case 172: case 232: {
-#line 1218 "VBNET.ATG"
+#line 1216 "VBNET.ATG"
ConversionType opConversionType = ConversionType.None;
if (la.kind == 161 || la.kind == 232) {
if (la.kind == 232) {
lexer.NextToken();
-#line 1219 "VBNET.ATG"
+#line 1217 "VBNET.ATG"
opConversionType = ConversionType.Implicit;
} else {
lexer.NextToken();
-#line 1220 "VBNET.ATG"
+#line 1218 "VBNET.ATG"
opConversionType = ConversionType.Explicit;
}
}
Expect(172);
-#line 1223 "VBNET.ATG"
+#line 1221 "VBNET.ATG"
m.Check(Modifiers.VBOperators);
Location startPos = t.Location;
TypeReference returnType = NullTypeReference.Instance;
@@ -2181,7 +2182,7 @@ out eventAccessorDeclaration);
List parameters = new List();
OverloadableOperator(
-#line 1232 "VBNET.ATG"
+#line 1230 "VBNET.ATG"
out operatorType);
Expect(37);
if (la.kind == 72) {
@@ -2189,16 +2190,16 @@ out operatorType);
}
Identifier();
-#line 1233 "VBNET.ATG"
+#line 1231 "VBNET.ATG"
operandName = t.val;
if (la.kind == 63) {
lexer.NextToken();
TypeName(
-#line 1234 "VBNET.ATG"
+#line 1232 "VBNET.ATG"
out operandType);
}
-#line 1235 "VBNET.ATG"
+#line 1233 "VBNET.ATG"
parameters.Add(new ParameterDeclarationExpression(operandType, operandName, ParameterModifiers.In));
while (la.kind == 22) {
lexer.NextToken();
@@ -2207,51 +2208,51 @@ out operandType);
}
Identifier();
-#line 1239 "VBNET.ATG"
+#line 1237 "VBNET.ATG"
operandName = t.val;
if (la.kind == 63) {
lexer.NextToken();
TypeName(
-#line 1240 "VBNET.ATG"
+#line 1238 "VBNET.ATG"
out operandType);
}
-#line 1241 "VBNET.ATG"
+#line 1239 "VBNET.ATG"
parameters.Add(new ParameterDeclarationExpression(operandType, operandName, ParameterModifiers.In));
}
Expect(38);
-#line 1244 "VBNET.ATG"
+#line 1242 "VBNET.ATG"
Location endPos = t.EndLocation;
if (la.kind == 63) {
lexer.NextToken();
while (la.kind == 40) {
AttributeSection(
-#line 1245 "VBNET.ATG"
+#line 1243 "VBNET.ATG"
out section);
-#line 1246 "VBNET.ATG"
+#line 1244 "VBNET.ATG"
if (section != null) {
section.AttributeTarget = "return";
attributes.Add(section);
}
}
TypeName(
-#line 1250 "VBNET.ATG"
+#line 1248 "VBNET.ATG"
out returnType);
-#line 1250 "VBNET.ATG"
+#line 1248 "VBNET.ATG"
endPos = t.EndLocation;
}
Expect(1);
Block(
-#line 1252 "VBNET.ATG"
+#line 1250 "VBNET.ATG"
out stmt);
Expect(113);
Expect(172);
EndOfStmt();
-#line 1254 "VBNET.ATG"
+#line 1252 "VBNET.ATG"
OperatorDeclaration operatorDeclaration = new OperatorDeclaration {
Modifier = m.Modifier,
Attributes = attributes,
@@ -2269,30 +2270,30 @@ out stmt);
break;
}
- default: SynErr(262); break;
+ default: SynErr(263); break;
}
}
void EnumMemberDecl(
-#line 766 "VBNET.ATG"
+#line 764 "VBNET.ATG"
out FieldDeclaration f) {
-#line 768 "VBNET.ATG"
+#line 766 "VBNET.ATG"
Expression expr = null;List attributes = new List();
AttributeSection section = null;
VariableDeclaration varDecl = null;
while (la.kind == 40) {
AttributeSection(
-#line 772 "VBNET.ATG"
+#line 770 "VBNET.ATG"
out section);
-#line 772 "VBNET.ATG"
+#line 770 "VBNET.ATG"
attributes.Add(section);
}
Identifier();
-#line 775 "VBNET.ATG"
+#line 773 "VBNET.ATG"
f = new FieldDeclaration(attributes);
varDecl = new VariableDeclaration(t.val);
f.Fields.Add(varDecl);
@@ -2301,10 +2302,10 @@ out section);
if (la.kind == 20) {
lexer.NextToken();
Expr(
-#line 780 "VBNET.ATG"
+#line 778 "VBNET.ATG"
out expr);
-#line 780 "VBNET.ATG"
+#line 778 "VBNET.ATG"
varDecl.Initializer = expr;
}
EndOfStmt();
@@ -2312,7 +2313,7 @@ out expr);
void InterfaceMemberDecl() {
-#line 657 "VBNET.ATG"
+#line 655 "VBNET.ATG"
TypeReference type =null;
List p = new List();
List templates = new List();
@@ -2324,33 +2325,33 @@ out expr);
if (StartOf(19)) {
while (la.kind == 40) {
AttributeSection(
-#line 665 "VBNET.ATG"
+#line 663 "VBNET.ATG"
out section);
-#line 665 "VBNET.ATG"
+#line 663 "VBNET.ATG"
attributes.Add(section);
}
while (StartOf(10)) {
MemberModifier(
-#line 668 "VBNET.ATG"
+#line 666 "VBNET.ATG"
mod);
}
if (la.kind == 119) {
lexer.NextToken();
-#line 672 "VBNET.ATG"
+#line 670 "VBNET.ATG"
mod.Check(Modifiers.VBInterfaceEvents);
Location startLocation = t.Location;
Identifier();
-#line 675 "VBNET.ATG"
+#line 673 "VBNET.ATG"
name = t.val;
if (la.kind == 37) {
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 676 "VBNET.ATG"
+#line 674 "VBNET.ATG"
p);
}
Expect(38);
@@ -2358,12 +2359,12 @@ p);
if (la.kind == 63) {
lexer.NextToken();
TypeName(
-#line 677 "VBNET.ATG"
+#line 675 "VBNET.ATG"
out type);
}
EndOfStmt();
-#line 680 "VBNET.ATG"
+#line 678 "VBNET.ATG"
EventDeclaration ed = new EventDeclaration {
Name = name, TypeReference = type, Modifier = mod.Modifier,
Parameters = p, Attributes = attributes,
@@ -2374,29 +2375,29 @@ out type);
} else if (la.kind == 210) {
lexer.NextToken();
-#line 690 "VBNET.ATG"
+#line 688 "VBNET.ATG"
Location startLocation = t.Location;
mod.Check(Modifiers.VBInterfaceMethods);
Identifier();
-#line 693 "VBNET.ATG"
+#line 691 "VBNET.ATG"
name = t.val;
TypeParameterList(
-#line 694 "VBNET.ATG"
+#line 692 "VBNET.ATG"
templates);
if (la.kind == 37) {
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 695 "VBNET.ATG"
+#line 693 "VBNET.ATG"
p);
}
Expect(38);
}
EndOfStmt();
-#line 698 "VBNET.ATG"
+#line 696 "VBNET.ATG"
MethodDeclaration md = new MethodDeclaration {
Name = name,
Modifier = mod.Modifier,
@@ -2412,22 +2413,22 @@ p);
} else if (la.kind == 127) {
lexer.NextToken();
-#line 713 "VBNET.ATG"
+#line 711 "VBNET.ATG"
mod.Check(Modifiers.VBInterfaceMethods);
Location startLocation = t.Location;
Identifier();
-#line 716 "VBNET.ATG"
+#line 714 "VBNET.ATG"
name = t.val;
TypeParameterList(
-#line 717 "VBNET.ATG"
+#line 715 "VBNET.ATG"
templates);
if (la.kind == 37) {
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 718 "VBNET.ATG"
+#line 716 "VBNET.ATG"
p);
}
Expect(38);
@@ -2436,15 +2437,15 @@ p);
lexer.NextToken();
while (la.kind == 40) {
AttributeSection(
-#line 719 "VBNET.ATG"
+#line 717 "VBNET.ATG"
out returnTypeAttributeSection);
}
TypeName(
-#line 719 "VBNET.ATG"
+#line 717 "VBNET.ATG"
out type);
}
-#line 721 "VBNET.ATG"
+#line 719 "VBNET.ATG"
if(type == null) {
type = new TypeReference("System.Object", true);
}
@@ -2465,19 +2466,19 @@ out type);
} else if (la.kind == 186) {
lexer.NextToken();
-#line 741 "VBNET.ATG"
+#line 739 "VBNET.ATG"
Location startLocation = t.Location;
mod.Check(Modifiers.VBInterfaceProperties);
Identifier();
-#line 744 "VBNET.ATG"
+#line 742 "VBNET.ATG"
name = t.val;
if (la.kind == 37) {
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 745 "VBNET.ATG"
+#line 743 "VBNET.ATG"
p);
}
Expect(38);
@@ -2485,134 +2486,134 @@ p);
if (la.kind == 63) {
lexer.NextToken();
TypeName(
-#line 746 "VBNET.ATG"
+#line 744 "VBNET.ATG"
out type);
}
-#line 748 "VBNET.ATG"
+#line 746 "VBNET.ATG"
if(type == null) {
type = new TypeReference("System.Object", true);
}
EndOfStmt();
-#line 754 "VBNET.ATG"
+#line 752 "VBNET.ATG"
PropertyDeclaration pd = new PropertyDeclaration(name, type, mod.Modifier, attributes);
pd.Parameters = p;
pd.EndLocation = t.EndLocation;
pd.StartLocation = startLocation;
AddChild(pd);
- } else SynErr(263);
+ } else SynErr(264);
} else if (StartOf(20)) {
NonModuleDeclaration(
-#line 762 "VBNET.ATG"
+#line 760 "VBNET.ATG"
mod, attributes);
- } else SynErr(264);
+ } else SynErr(265);
}
void Expr(
-#line 1649 "VBNET.ATG"
+#line 1647 "VBNET.ATG"
out Expression expr) {
-#line 1650 "VBNET.ATG"
+#line 1648 "VBNET.ATG"
expr = null;
if (
-#line 1651 "VBNET.ATG"
+#line 1649 "VBNET.ATG"
IsQueryExpression() ) {
QueryExpr(
-#line 1652 "VBNET.ATG"
+#line 1650 "VBNET.ATG"
out expr);
} else if (la.kind == 127 || la.kind == 210) {
LambdaExpr(
-#line 1653 "VBNET.ATG"
+#line 1651 "VBNET.ATG"
out expr);
} else if (StartOf(21)) {
DisjunctionExpr(
-#line 1654 "VBNET.ATG"
+#line 1652 "VBNET.ATG"
out expr);
- } else SynErr(265);
+ } else SynErr(266);
}
void ImplementsClause(
-#line 1622 "VBNET.ATG"
+#line 1620 "VBNET.ATG"
out List baseInterfaces) {
-#line 1624 "VBNET.ATG"
+#line 1622 "VBNET.ATG"
baseInterfaces = new List();
TypeReference type = null;
string memberName = null;
Expect(136);
NonArrayTypeName(
-#line 1629 "VBNET.ATG"
+#line 1627 "VBNET.ATG"
out type, false);
-#line 1630 "VBNET.ATG"
+#line 1628 "VBNET.ATG"
if (type != null) memberName = TypeReference.StripLastIdentifierFromType(ref type);
-#line 1631 "VBNET.ATG"
+#line 1629 "VBNET.ATG"
baseInterfaces.Add(new InterfaceImplementation(type, memberName));
while (la.kind == 22) {
lexer.NextToken();
NonArrayTypeName(
-#line 1633 "VBNET.ATG"
+#line 1631 "VBNET.ATG"
out type, false);
-#line 1634 "VBNET.ATG"
+#line 1632 "VBNET.ATG"
if (type != null) memberName = TypeReference.StripLastIdentifierFromType(ref type);
-#line 1635 "VBNET.ATG"
+#line 1633 "VBNET.ATG"
baseInterfaces.Add(new InterfaceImplementation(type, memberName));
}
}
void HandlesClause(
-#line 1580 "VBNET.ATG"
+#line 1578 "VBNET.ATG"
out List handlesClause) {
-#line 1582 "VBNET.ATG"
+#line 1580 "VBNET.ATG"
handlesClause = new List();
string name;
Expect(134);
EventMemberSpecifier(
-#line 1585 "VBNET.ATG"
+#line 1583 "VBNET.ATG"
out name);
-#line 1585 "VBNET.ATG"
+#line 1583 "VBNET.ATG"
if (name != null) handlesClause.Add(name);
while (la.kind == 22) {
lexer.NextToken();
EventMemberSpecifier(
-#line 1586 "VBNET.ATG"
+#line 1584 "VBNET.ATG"
out name);
-#line 1586 "VBNET.ATG"
+#line 1584 "VBNET.ATG"
if (name != null) handlesClause.Add(name);
}
}
void Block(
-#line 2912 "VBNET.ATG"
+#line 2910 "VBNET.ATG"
out Statement stmt) {
-#line 2915 "VBNET.ATG"
+#line 2913 "VBNET.ATG"
BlockStatement blockStmt = new BlockStatement();
/* in snippet parsing mode, t might be null */
if (t != null) blockStmt.StartLocation = t.EndLocation;
BlockStart(blockStmt);
while (StartOf(22) ||
-#line 2921 "VBNET.ATG"
+#line 2919 "VBNET.ATG"
IsEndStmtAhead()) {
if (
-#line 2921 "VBNET.ATG"
+#line 2919 "VBNET.ATG"
IsEndStmtAhead()) {
Expect(113);
EndOfStmt();
-#line 2921 "VBNET.ATG"
+#line 2919 "VBNET.ATG"
AddChild(new EndStatement());
} else {
Statement();
@@ -2620,7 +2621,7 @@ IsEndStmtAhead()) {
}
}
-#line 2926 "VBNET.ATG"
+#line 2924 "VBNET.ATG"
stmt = blockStmt;
if (t != null) blockStmt.EndLocation = t.EndLocation;
BlockEnd();
@@ -2628,28 +2629,28 @@ IsEndStmtAhead()) {
}
void Charset(
-#line 1572 "VBNET.ATG"
+#line 1570 "VBNET.ATG"
out CharsetModifier charsetModifier) {
-#line 1573 "VBNET.ATG"
+#line 1571 "VBNET.ATG"
charsetModifier = CharsetModifier.None;
if (la.kind == 127 || la.kind == 210) {
} else if (la.kind == 62) {
lexer.NextToken();
-#line 1574 "VBNET.ATG"
+#line 1572 "VBNET.ATG"
charsetModifier = CharsetModifier.Ansi;
} else if (la.kind == 66) {
lexer.NextToken();
-#line 1575 "VBNET.ATG"
+#line 1573 "VBNET.ATG"
charsetModifier = CharsetModifier.Auto;
} else if (la.kind == 223) {
lexer.NextToken();
-#line 1576 "VBNET.ATG"
+#line 1574 "VBNET.ATG"
charsetModifier = CharsetModifier.Unicode;
- } else SynErr(266);
+ } else SynErr(267);
}
void IdentifierForFieldDeclaration() {
@@ -2770,15 +2771,15 @@ out CharsetModifier charsetModifier) {
lexer.NextToken();
break;
}
- default: SynErr(267); break;
+ default: SynErr(268); break;
}
}
void VariableDeclaratorPartAfterIdentifier(
-#line 1457 "VBNET.ATG"
+#line 1455 "VBNET.ATG"
List fieldDeclaration, string name) {
-#line 1459 "VBNET.ATG"
+#line 1457 "VBNET.ATG"
Expression expr = null;
TypeReference type = null;
ArrayList rank = null;
@@ -2786,28 +2787,28 @@ List fieldDeclaration, string name) {
Location startLocation = t.Location;
if (
-#line 1465 "VBNET.ATG"
+#line 1463 "VBNET.ATG"
IsSize() && !IsDims()) {
ArrayInitializationModifier(
-#line 1465 "VBNET.ATG"
+#line 1463 "VBNET.ATG"
out dimension);
}
if (
-#line 1466 "VBNET.ATG"
+#line 1464 "VBNET.ATG"
IsDims()) {
ArrayNameModifier(
-#line 1466 "VBNET.ATG"
+#line 1464 "VBNET.ATG"
out rank);
}
if (
-#line 1468 "VBNET.ATG"
+#line 1466 "VBNET.ATG"
IsObjectCreation()) {
Expect(63);
ObjectCreateExpression(
-#line 1468 "VBNET.ATG"
+#line 1466 "VBNET.ATG"
out expr);
-#line 1470 "VBNET.ATG"
+#line 1468 "VBNET.ATG"
if (expr is ObjectCreateExpression) {
type = ((ObjectCreateExpression)expr).CreateType.Clone();
} else {
@@ -2818,10 +2819,10 @@ out expr);
if (la.kind == 63) {
lexer.NextToken();
TypeName(
-#line 1477 "VBNET.ATG"
+#line 1475 "VBNET.ATG"
out type);
-#line 1479 "VBNET.ATG"
+#line 1477 "VBNET.ATG"
if (type != null) {
for (int i = fieldDeclaration.Count - 1; i >= 0; i--) {
VariableDeclaration vd = fieldDeclaration[i];
@@ -2834,7 +2835,7 @@ out type);
}
-#line 1491 "VBNET.ATG"
+#line 1489 "VBNET.ATG"
if (type == null && (dimension != null || rank != null)) {
type = new TypeReference("");
}
@@ -2861,12 +2862,12 @@ out type);
if (la.kind == 20) {
lexer.NextToken();
Expr(
-#line 1514 "VBNET.ATG"
+#line 1512 "VBNET.ATG"
out expr);
}
- } else SynErr(268);
+ } else SynErr(269);
-#line 1517 "VBNET.ATG"
+#line 1515 "VBNET.ATG"
VariableDeclaration varDecl = new VariableDeclaration(name, expr, type);
varDecl.StartLocation = startLocation;
varDecl.EndLocation = t.Location;
@@ -2875,22 +2876,22 @@ out expr);
}
void VariableDeclarator(
-#line 1451 "VBNET.ATG"
+#line 1449 "VBNET.ATG"
List fieldDeclaration) {
Identifier();
-#line 1453 "VBNET.ATG"
+#line 1451 "VBNET.ATG"
string name = t.val;
VariableDeclaratorPartAfterIdentifier(
-#line 1454 "VBNET.ATG"
+#line 1452 "VBNET.ATG"
fieldDeclaration, name);
}
void ConstantDeclarator(
-#line 1432 "VBNET.ATG"
+#line 1430 "VBNET.ATG"
List constantDeclaration) {
-#line 1434 "VBNET.ATG"
+#line 1432 "VBNET.ATG"
Expression expr = null;
TypeReference type = null;
string name = String.Empty;
@@ -2898,20 +2899,20 @@ List constantDeclaration) {
Identifier();
-#line 1439 "VBNET.ATG"
+#line 1437 "VBNET.ATG"
name = t.val; location = t.Location;
if (la.kind == 63) {
lexer.NextToken();
TypeName(
-#line 1440 "VBNET.ATG"
+#line 1438 "VBNET.ATG"
out type);
}
Expect(20);
Expr(
-#line 1441 "VBNET.ATG"
+#line 1439 "VBNET.ATG"
out expr);
-#line 1443 "VBNET.ATG"
+#line 1441 "VBNET.ATG"
VariableDeclaration f = new VariableDeclaration(name, expr);
f.TypeReference = type;
f.StartLocation = location;
@@ -2920,10 +2921,10 @@ out expr);
}
void ObjectCreateExpression(
-#line 2080 "VBNET.ATG"
+#line 2078 "VBNET.ATG"
out Expression oce) {
-#line 2082 "VBNET.ATG"
+#line 2080 "VBNET.ATG"
TypeReference type = null;
CollectionInitializerExpression initializer = null;
List arguments = null;
@@ -2934,39 +2935,39 @@ out Expression oce) {
Expect(162);
if (StartOf(8)) {
NonArrayTypeName(
-#line 2090 "VBNET.ATG"
+#line 2088 "VBNET.ATG"
out type, false);
if (la.kind == 37) {
lexer.NextToken();
NormalOrReDimArgumentList(
-#line 2091 "VBNET.ATG"
+#line 2089 "VBNET.ATG"
out arguments, out canBeNormal, out canBeReDim);
Expect(38);
if (la.kind == 35 ||
-#line 2092 "VBNET.ATG"
+#line 2090 "VBNET.ATG"
la.kind == Tokens.OpenParenthesis) {
if (
-#line 2092 "VBNET.ATG"
+#line 2090 "VBNET.ATG"
la.kind == Tokens.OpenParenthesis) {
ArrayTypeModifiers(
-#line 2093 "VBNET.ATG"
+#line 2091 "VBNET.ATG"
out dimensions);
CollectionInitializer(
-#line 2094 "VBNET.ATG"
+#line 2092 "VBNET.ATG"
out initializer);
} else {
CollectionInitializer(
-#line 2095 "VBNET.ATG"
+#line 2093 "VBNET.ATG"
out initializer);
}
}
-#line 2097 "VBNET.ATG"
+#line 2095 "VBNET.ATG"
if (canBeReDim && !canBeNormal && initializer == null) initializer = new CollectionInitializerExpression();
}
}
-#line 2101 "VBNET.ATG"
+#line 2099 "VBNET.ATG"
if (initializer == null) {
oce = new ObjectCreateExpression(type, arguments);
} else {
@@ -2981,34 +2982,34 @@ out initializer);
if (la.kind == 126 || la.kind == 233) {
if (la.kind == 233) {
-#line 2116 "VBNET.ATG"
+#line 2114 "VBNET.ATG"
MemberInitializerExpression memberInitializer = null;
lexer.NextToken();
-#line 2120 "VBNET.ATG"
+#line 2118 "VBNET.ATG"
CollectionInitializerExpression memberInitializers = new CollectionInitializerExpression();
memberInitializers.StartLocation = la.Location;
Expect(35);
MemberInitializer(
-#line 2124 "VBNET.ATG"
+#line 2122 "VBNET.ATG"
out memberInitializer);
-#line 2125 "VBNET.ATG"
+#line 2123 "VBNET.ATG"
memberInitializers.CreateExpressions.Add(memberInitializer);
while (la.kind == 22) {
lexer.NextToken();
MemberInitializer(
-#line 2127 "VBNET.ATG"
+#line 2125 "VBNET.ATG"
out memberInitializer);
-#line 2128 "VBNET.ATG"
+#line 2126 "VBNET.ATG"
memberInitializers.CreateExpressions.Add(memberInitializer);
}
Expect(36);
-#line 2132 "VBNET.ATG"
+#line 2130 "VBNET.ATG"
memberInitializers.EndLocation = t.Location;
if(oce is ObjectCreateExpression)
{
@@ -3018,10 +3019,10 @@ out memberInitializer);
} else {
lexer.NextToken();
CollectionInitializer(
-#line 2142 "VBNET.ATG"
+#line 2140 "VBNET.ATG"
out initializer);
-#line 2144 "VBNET.ATG"
+#line 2142 "VBNET.ATG"
if(oce is ObjectCreateExpression)
((ObjectCreateExpression)oce).ObjectInitializer = initializer;
@@ -3030,10 +3031,10 @@ out initializer);
}
void AccessorDecls(
-#line 1366 "VBNET.ATG"
+#line 1364 "VBNET.ATG"
out PropertyGetRegion getBlock, out PropertySetRegion setBlock) {
-#line 1368 "VBNET.ATG"
+#line 1366 "VBNET.ATG"
List attributes = new List();
AttributeSection section;
getBlock = null;
@@ -3041,60 +3042,60 @@ out PropertyGetRegion getBlock, out PropertySetRegion setBlock) {
while (la.kind == 40) {
AttributeSection(
-#line 1373 "VBNET.ATG"
+#line 1371 "VBNET.ATG"
out section);
-#line 1373 "VBNET.ATG"
+#line 1371 "VBNET.ATG"
attributes.Add(section);
}
if (StartOf(24)) {
GetAccessorDecl(
-#line 1375 "VBNET.ATG"
+#line 1373 "VBNET.ATG"
out getBlock, attributes);
if (StartOf(25)) {
-#line 1377 "VBNET.ATG"
+#line 1375 "VBNET.ATG"
attributes = new List();
while (la.kind == 40) {
AttributeSection(
-#line 1378 "VBNET.ATG"
+#line 1376 "VBNET.ATG"
out section);
-#line 1378 "VBNET.ATG"
+#line 1376 "VBNET.ATG"
attributes.Add(section);
}
SetAccessorDecl(
-#line 1379 "VBNET.ATG"
+#line 1377 "VBNET.ATG"
out setBlock, attributes);
}
} else if (StartOf(26)) {
SetAccessorDecl(
-#line 1382 "VBNET.ATG"
+#line 1380 "VBNET.ATG"
out setBlock, attributes);
if (StartOf(27)) {
-#line 1384 "VBNET.ATG"
+#line 1382 "VBNET.ATG"
attributes = new List();
while (la.kind == 40) {
AttributeSection(
-#line 1385 "VBNET.ATG"
+#line 1383 "VBNET.ATG"
out section);
-#line 1385 "VBNET.ATG"
+#line 1383 "VBNET.ATG"
attributes.Add(section);
}
GetAccessorDecl(
-#line 1386 "VBNET.ATG"
+#line 1384 "VBNET.ATG"
out getBlock, attributes);
}
- } else SynErr(269);
+ } else SynErr(270);
}
void EventAccessorDeclaration(
-#line 1329 "VBNET.ATG"
+#line 1327 "VBNET.ATG"
out EventAddRemoveRegion eventAccessorDeclaration) {
-#line 1331 "VBNET.ATG"
+#line 1329 "VBNET.ATG"
Statement stmt = null;
List p = new List();
AttributeSection section;
@@ -3103,10 +3104,10 @@ out EventAddRemoveRegion eventAccessorDeclaration) {
while (la.kind == 40) {
AttributeSection(
-#line 1337 "VBNET.ATG"
+#line 1335 "VBNET.ATG"
out section);
-#line 1337 "VBNET.ATG"
+#line 1335 "VBNET.ATG"
attributes.Add(section);
}
if (la.kind == 56) {
@@ -3115,20 +3116,20 @@ out section);
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 1339 "VBNET.ATG"
+#line 1337 "VBNET.ATG"
p);
}
Expect(38);
}
Expect(1);
Block(
-#line 1340 "VBNET.ATG"
+#line 1338 "VBNET.ATG"
out stmt);
Expect(113);
Expect(56);
EndOfStmt();
-#line 1342 "VBNET.ATG"
+#line 1340 "VBNET.ATG"
eventAccessorDeclaration = new EventAddRegion(attributes);
eventAccessorDeclaration.Block = (BlockStatement)stmt;
eventAccessorDeclaration.Parameters = p;
@@ -3139,20 +3140,20 @@ out stmt);
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 1347 "VBNET.ATG"
+#line 1345 "VBNET.ATG"
p);
}
Expect(38);
}
Expect(1);
Block(
-#line 1348 "VBNET.ATG"
+#line 1346 "VBNET.ATG"
out stmt);
Expect(113);
Expect(193);
EndOfStmt();
-#line 1350 "VBNET.ATG"
+#line 1348 "VBNET.ATG"
eventAccessorDeclaration = new EventRemoveRegion(attributes);
eventAccessorDeclaration.Block = (BlockStatement)stmt;
eventAccessorDeclaration.Parameters = p;
@@ -3163,185 +3164,185 @@ out stmt);
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 1355 "VBNET.ATG"
+#line 1353 "VBNET.ATG"
p);
}
Expect(38);
}
Expect(1);
Block(
-#line 1356 "VBNET.ATG"
+#line 1354 "VBNET.ATG"
out stmt);
Expect(113);
Expect(189);
EndOfStmt();
-#line 1358 "VBNET.ATG"
+#line 1356 "VBNET.ATG"
eventAccessorDeclaration = new EventRaiseRegion(attributes);
eventAccessorDeclaration.Block = (BlockStatement)stmt;
eventAccessorDeclaration.Parameters = p;
- } else SynErr(270);
+ } else SynErr(271);
}
void OverloadableOperator(
-#line 1271 "VBNET.ATG"
+#line 1269 "VBNET.ATG"
out OverloadableOperatorType operatorType) {
-#line 1272 "VBNET.ATG"
+#line 1270 "VBNET.ATG"
operatorType = OverloadableOperatorType.None;
switch (la.kind) {
case 31: {
lexer.NextToken();
-#line 1274 "VBNET.ATG"
+#line 1272 "VBNET.ATG"
operatorType = OverloadableOperatorType.Add;
break;
}
case 30: {
lexer.NextToken();
-#line 1276 "VBNET.ATG"
+#line 1274 "VBNET.ATG"
operatorType = OverloadableOperatorType.Subtract;
break;
}
case 34: {
lexer.NextToken();
-#line 1278 "VBNET.ATG"
+#line 1276 "VBNET.ATG"
operatorType = OverloadableOperatorType.Multiply;
break;
}
case 24: {
lexer.NextToken();
-#line 1280 "VBNET.ATG"
+#line 1278 "VBNET.ATG"
operatorType = OverloadableOperatorType.Divide;
break;
}
case 25: {
lexer.NextToken();
-#line 1282 "VBNET.ATG"
+#line 1280 "VBNET.ATG"
operatorType = OverloadableOperatorType.DivideInteger;
break;
}
case 23: {
lexer.NextToken();
-#line 1284 "VBNET.ATG"
+#line 1282 "VBNET.ATG"
operatorType = OverloadableOperatorType.Concat;
break;
}
case 150: {
lexer.NextToken();
-#line 1286 "VBNET.ATG"
+#line 1284 "VBNET.ATG"
operatorType = OverloadableOperatorType.Like;
break;
}
case 154: {
lexer.NextToken();
-#line 1288 "VBNET.ATG"
+#line 1286 "VBNET.ATG"
operatorType = OverloadableOperatorType.Modulus;
break;
}
case 60: {
lexer.NextToken();
-#line 1290 "VBNET.ATG"
+#line 1288 "VBNET.ATG"
operatorType = OverloadableOperatorType.BitwiseAnd;
break;
}
case 175: {
lexer.NextToken();
-#line 1292 "VBNET.ATG"
+#line 1290 "VBNET.ATG"
operatorType = OverloadableOperatorType.BitwiseOr;
break;
}
case 236: {
lexer.NextToken();
-#line 1294 "VBNET.ATG"
+#line 1292 "VBNET.ATG"
operatorType = OverloadableOperatorType.ExclusiveOr;
break;
}
case 32: {
lexer.NextToken();
-#line 1296 "VBNET.ATG"
+#line 1294 "VBNET.ATG"
operatorType = OverloadableOperatorType.Power;
break;
}
case 44: {
lexer.NextToken();
-#line 1298 "VBNET.ATG"
+#line 1296 "VBNET.ATG"
operatorType = OverloadableOperatorType.ShiftLeft;
break;
}
case 45: {
lexer.NextToken();
-#line 1300 "VBNET.ATG"
+#line 1298 "VBNET.ATG"
operatorType = OverloadableOperatorType.ShiftRight;
break;
}
case 20: {
lexer.NextToken();
-#line 1302 "VBNET.ATG"
+#line 1300 "VBNET.ATG"
operatorType = OverloadableOperatorType.Equality;
break;
}
case 41: {
lexer.NextToken();
-#line 1304 "VBNET.ATG"
+#line 1302 "VBNET.ATG"
operatorType = OverloadableOperatorType.InEquality;
break;
}
case 40: {
lexer.NextToken();
-#line 1306 "VBNET.ATG"
+#line 1304 "VBNET.ATG"
operatorType = OverloadableOperatorType.LessThan;
break;
}
case 43: {
lexer.NextToken();
-#line 1308 "VBNET.ATG"
+#line 1306 "VBNET.ATG"
operatorType = OverloadableOperatorType.LessThanOrEqual;
break;
}
case 39: {
lexer.NextToken();
-#line 1310 "VBNET.ATG"
+#line 1308 "VBNET.ATG"
operatorType = OverloadableOperatorType.GreaterThan;
break;
}
case 42: {
lexer.NextToken();
-#line 1312 "VBNET.ATG"
+#line 1310 "VBNET.ATG"
operatorType = OverloadableOperatorType.GreaterThanOrEqual;
break;
}
case 94: {
lexer.NextToken();
-#line 1314 "VBNET.ATG"
+#line 1312 "VBNET.ATG"
operatorType = OverloadableOperatorType.CType;
break;
}
case 2: case 58: case 62: case 64: case 65: case 66: case 67: case 70: case 87: case 98: case 104: case 107: case 116: case 121: case 126: case 133: case 139: case 143: case 146: case 147: case 170: case 176: case 178: case 184: case 203: case 212: case 213: case 223: case 224: case 230: {
Identifier();
-#line 1318 "VBNET.ATG"
+#line 1316 "VBNET.ATG"
string opName = t.val;
if (string.Equals(opName, "istrue", StringComparison.InvariantCultureIgnoreCase)) {
operatorType = OverloadableOperatorType.IsTrue;
@@ -3353,72 +3354,72 @@ out OverloadableOperatorType operatorType) {
break;
}
- default: SynErr(271); break;
+ default: SynErr(272); break;
}
}
void GetAccessorDecl(
-#line 1392 "VBNET.ATG"
+#line 1390 "VBNET.ATG"
out PropertyGetRegion getBlock, List attributes) {
-#line 1393 "VBNET.ATG"
+#line 1391 "VBNET.ATG"
Statement stmt = null; Modifiers m;
PropertyAccessorAccessModifier(
-#line 1395 "VBNET.ATG"
+#line 1393 "VBNET.ATG"
out m);
Expect(128);
-#line 1397 "VBNET.ATG"
+#line 1395 "VBNET.ATG"
Location startLocation = t.Location;
Expect(1);
Block(
-#line 1399 "VBNET.ATG"
+#line 1397 "VBNET.ATG"
out stmt);
-#line 1400 "VBNET.ATG"
+#line 1398 "VBNET.ATG"
getBlock = new PropertyGetRegion((BlockStatement)stmt, attributes);
Expect(113);
Expect(128);
-#line 1402 "VBNET.ATG"
+#line 1400 "VBNET.ATG"
getBlock.Modifier = m;
-#line 1403 "VBNET.ATG"
+#line 1401 "VBNET.ATG"
getBlock.StartLocation = startLocation; getBlock.EndLocation = t.EndLocation;
EndOfStmt();
}
void SetAccessorDecl(
-#line 1408 "VBNET.ATG"
+#line 1406 "VBNET.ATG"
out PropertySetRegion setBlock, List attributes) {
-#line 1410 "VBNET.ATG"
+#line 1408 "VBNET.ATG"
Statement stmt = null;
List p = new List();
Modifiers m;
PropertyAccessorAccessModifier(
-#line 1415 "VBNET.ATG"
+#line 1413 "VBNET.ATG"
out m);
Expect(198);
-#line 1417 "VBNET.ATG"
+#line 1415 "VBNET.ATG"
Location startLocation = t.Location;
if (la.kind == 37) {
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 1418 "VBNET.ATG"
+#line 1416 "VBNET.ATG"
p);
}
Expect(38);
}
Expect(1);
Block(
-#line 1420 "VBNET.ATG"
+#line 1418 "VBNET.ATG"
out stmt);
-#line 1422 "VBNET.ATG"
+#line 1420 "VBNET.ATG"
setBlock = new PropertySetRegion((BlockStatement)stmt, attributes);
setBlock.Modifier = m;
setBlock.Parameters = p;
@@ -3426,151 +3427,151 @@ out stmt);
Expect(113);
Expect(198);
-#line 1427 "VBNET.ATG"
+#line 1425 "VBNET.ATG"
setBlock.StartLocation = startLocation; setBlock.EndLocation = t.EndLocation;
EndOfStmt();
}
void PropertyAccessorAccessModifier(
-#line 3630 "VBNET.ATG"
+#line 3628 "VBNET.ATG"
out Modifiers m) {
-#line 3631 "VBNET.ATG"
+#line 3629 "VBNET.ATG"
m = Modifiers.None;
while (StartOf(28)) {
if (la.kind == 188) {
lexer.NextToken();
-#line 3633 "VBNET.ATG"
+#line 3631 "VBNET.ATG"
m |= Modifiers.Public;
} else if (la.kind == 187) {
lexer.NextToken();
-#line 3634 "VBNET.ATG"
+#line 3632 "VBNET.ATG"
m |= Modifiers.Protected;
} else if (la.kind == 125) {
lexer.NextToken();
-#line 3635 "VBNET.ATG"
+#line 3633 "VBNET.ATG"
m |= Modifiers.Internal;
} else {
lexer.NextToken();
-#line 3636 "VBNET.ATG"
+#line 3634 "VBNET.ATG"
m |= Modifiers.Private;
}
}
}
void ArrayInitializationModifier(
-#line 1525 "VBNET.ATG"
+#line 1523 "VBNET.ATG"
out List arrayModifiers) {
-#line 1527 "VBNET.ATG"
+#line 1525 "VBNET.ATG"
arrayModifiers = null;
Expect(37);
InitializationRankList(
-#line 1529 "VBNET.ATG"
+#line 1527 "VBNET.ATG"
out arrayModifiers);
Expect(38);
}
void ArrayNameModifier(
-#line 2707 "VBNET.ATG"
+#line 2705 "VBNET.ATG"
out ArrayList arrayModifiers) {
-#line 2709 "VBNET.ATG"
+#line 2707 "VBNET.ATG"
arrayModifiers = null;
ArrayTypeModifiers(
-#line 2711 "VBNET.ATG"
+#line 2709 "VBNET.ATG"
out arrayModifiers);
}
void InitializationRankList(
-#line 1533 "VBNET.ATG"
+#line 1531 "VBNET.ATG"
out List rank) {
-#line 1535 "VBNET.ATG"
+#line 1533 "VBNET.ATG"
rank = new List();
Expression expr = null;
Expr(
-#line 1538 "VBNET.ATG"
+#line 1536 "VBNET.ATG"
out expr);
if (la.kind == 216) {
lexer.NextToken();
-#line 1539 "VBNET.ATG"
+#line 1537 "VBNET.ATG"
EnsureIsZero(expr);
Expr(
-#line 1540 "VBNET.ATG"
+#line 1538 "VBNET.ATG"
out expr);
}
-#line 1542 "VBNET.ATG"
+#line 1540 "VBNET.ATG"
if (expr != null) { rank.Add(expr); }
while (la.kind == 22) {
lexer.NextToken();
Expr(
-#line 1544 "VBNET.ATG"
+#line 1542 "VBNET.ATG"
out expr);
if (la.kind == 216) {
lexer.NextToken();
-#line 1545 "VBNET.ATG"
+#line 1543 "VBNET.ATG"
EnsureIsZero(expr);
Expr(
-#line 1546 "VBNET.ATG"
+#line 1544 "VBNET.ATG"
out expr);
}
-#line 1548 "VBNET.ATG"
+#line 1546 "VBNET.ATG"
if (expr != null) { rank.Add(expr); }
}
}
void CollectionInitializer(
-#line 1553 "VBNET.ATG"
+#line 1551 "VBNET.ATG"
out CollectionInitializerExpression outExpr) {
-#line 1555 "VBNET.ATG"
+#line 1553 "VBNET.ATG"
Expression expr = null;
CollectionInitializerExpression initializer = new CollectionInitializerExpression();
Expect(35);
if (StartOf(29)) {
Expr(
-#line 1560 "VBNET.ATG"
+#line 1558 "VBNET.ATG"
out expr);
-#line 1562 "VBNET.ATG"
+#line 1560 "VBNET.ATG"
if (expr != null) { initializer.CreateExpressions.Add(expr); }
while (
-#line 1565 "VBNET.ATG"
+#line 1563 "VBNET.ATG"
NotFinalComma()) {
Expect(22);
Expr(
-#line 1565 "VBNET.ATG"
+#line 1563 "VBNET.ATG"
out expr);
-#line 1566 "VBNET.ATG"
+#line 1564 "VBNET.ATG"
if (expr != null) { initializer.CreateExpressions.Add(expr); }
}
}
Expect(36);
-#line 1569 "VBNET.ATG"
+#line 1567 "VBNET.ATG"
outExpr = initializer;
}
void EventMemberSpecifier(
-#line 1639 "VBNET.ATG"
+#line 1637 "VBNET.ATG"
out string name) {
-#line 1640 "VBNET.ATG"
+#line 1638 "VBNET.ATG"
string eventName;
if (StartOf(4)) {
Identifier();
@@ -3578,198 +3579,198 @@ out string name) {
lexer.NextToken();
} else if (la.kind == 153) {
lexer.NextToken();
- } else SynErr(272);
+ } else SynErr(273);
-#line 1643 "VBNET.ATG"
+#line 1641 "VBNET.ATG"
name = t.val;
Expect(26);
IdentifierOrKeyword(
-#line 1645 "VBNET.ATG"
+#line 1643 "VBNET.ATG"
out eventName);
-#line 1646 "VBNET.ATG"
+#line 1644 "VBNET.ATG"
name = name + "." + eventName;
}
void IdentifierOrKeyword(
-#line 3563 "VBNET.ATG"
+#line 3561 "VBNET.ATG"
out string name) {
lexer.NextToken();
-#line 3565 "VBNET.ATG"
+#line 3563 "VBNET.ATG"
name = t.val;
}
void QueryExpr(
-#line 2231 "VBNET.ATG"
+#line 2229 "VBNET.ATG"
out Expression expr) {
-#line 2233 "VBNET.ATG"
+#line 2231 "VBNET.ATG"
QueryExpressionVB qexpr = new QueryExpressionVB();
qexpr.StartLocation = la.Location;
expr = qexpr;
FromOrAggregateQueryOperator(
-#line 2237 "VBNET.ATG"
+#line 2235 "VBNET.ATG"
qexpr.Clauses);
while (StartOf(30)) {
QueryOperator(
-#line 2238 "VBNET.ATG"
+#line 2236 "VBNET.ATG"
qexpr.Clauses);
}
-#line 2240 "VBNET.ATG"
+#line 2238 "VBNET.ATG"
qexpr.EndLocation = t.EndLocation;
}
void LambdaExpr(
-#line 2151 "VBNET.ATG"
+#line 2149 "VBNET.ATG"
out Expression expr) {
-#line 2153 "VBNET.ATG"
+#line 2151 "VBNET.ATG"
LambdaExpression lambda = null;
if (la.kind == 210) {
SubLambdaExpression(
-#line 2155 "VBNET.ATG"
+#line 2153 "VBNET.ATG"
out lambda);
} else if (la.kind == 127) {
FunctionLambdaExpression(
-#line 2156 "VBNET.ATG"
+#line 2154 "VBNET.ATG"
out lambda);
- } else SynErr(273);
+ } else SynErr(274);
-#line 2157 "VBNET.ATG"
+#line 2155 "VBNET.ATG"
expr = lambda;
}
void DisjunctionExpr(
-#line 1924 "VBNET.ATG"
+#line 1922 "VBNET.ATG"
out Expression outExpr) {
-#line 1926 "VBNET.ATG"
+#line 1924 "VBNET.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
ConjunctionExpr(
-#line 1929 "VBNET.ATG"
+#line 1927 "VBNET.ATG"
out outExpr);
while (la.kind == 175 || la.kind == 177 || la.kind == 236) {
if (la.kind == 175) {
lexer.NextToken();
-#line 1932 "VBNET.ATG"
+#line 1930 "VBNET.ATG"
op = BinaryOperatorType.BitwiseOr;
} else if (la.kind == 177) {
lexer.NextToken();
-#line 1933 "VBNET.ATG"
+#line 1931 "VBNET.ATG"
op = BinaryOperatorType.LogicalOr;
} else {
lexer.NextToken();
-#line 1934 "VBNET.ATG"
+#line 1932 "VBNET.ATG"
op = BinaryOperatorType.ExclusiveOr;
}
ConjunctionExpr(
-#line 1936 "VBNET.ATG"
+#line 1934 "VBNET.ATG"
out expr);
-#line 1936 "VBNET.ATG"
+#line 1934 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
void AssignmentOperator(
-#line 1657 "VBNET.ATG"
+#line 1655 "VBNET.ATG"
out AssignmentOperatorType op) {
-#line 1658 "VBNET.ATG"
+#line 1656 "VBNET.ATG"
op = AssignmentOperatorType.None;
switch (la.kind) {
case 20: {
lexer.NextToken();
-#line 1659 "VBNET.ATG"
+#line 1657 "VBNET.ATG"
op = AssignmentOperatorType.Assign;
break;
}
case 54: {
lexer.NextToken();
-#line 1660 "VBNET.ATG"
+#line 1658 "VBNET.ATG"
op = AssignmentOperatorType.ConcatString;
break;
}
case 46: {
lexer.NextToken();
-#line 1661 "VBNET.ATG"
+#line 1659 "VBNET.ATG"
op = AssignmentOperatorType.Add;
break;
}
case 48: {
lexer.NextToken();
-#line 1662 "VBNET.ATG"
+#line 1660 "VBNET.ATG"
op = AssignmentOperatorType.Subtract;
break;
}
case 49: {
lexer.NextToken();
-#line 1663 "VBNET.ATG"
+#line 1661 "VBNET.ATG"
op = AssignmentOperatorType.Multiply;
break;
}
case 50: {
lexer.NextToken();
-#line 1664 "VBNET.ATG"
+#line 1662 "VBNET.ATG"
op = AssignmentOperatorType.Divide;
break;
}
case 51: {
lexer.NextToken();
-#line 1665 "VBNET.ATG"
+#line 1663 "VBNET.ATG"
op = AssignmentOperatorType.DivideInteger;
break;
}
case 47: {
lexer.NextToken();
-#line 1666 "VBNET.ATG"
+#line 1664 "VBNET.ATG"
op = AssignmentOperatorType.Power;
break;
}
case 52: {
lexer.NextToken();
-#line 1667 "VBNET.ATG"
+#line 1665 "VBNET.ATG"
op = AssignmentOperatorType.ShiftLeft;
break;
}
case 53: {
lexer.NextToken();
-#line 1668 "VBNET.ATG"
+#line 1666 "VBNET.ATG"
op = AssignmentOperatorType.ShiftRight;
break;
}
- default: SynErr(274); break;
+ default: SynErr(275); break;
}
}
void SimpleExpr(
-#line 1672 "VBNET.ATG"
+#line 1670 "VBNET.ATG"
out Expression pexpr) {
-#line 1673 "VBNET.ATG"
+#line 1671 "VBNET.ATG"
string name;
SimpleNonInvocationExpression(
-#line 1675 "VBNET.ATG"
+#line 1673 "VBNET.ATG"
out pexpr);
while (StartOf(31)) {
if (la.kind == 26) {
@@ -3777,78 +3778,78 @@ out pexpr);
if (la.kind == 10) {
lexer.NextToken();
IdentifierOrKeyword(
-#line 1678 "VBNET.ATG"
+#line 1676 "VBNET.ATG"
out name);
Expect(11);
-#line 1679 "VBNET.ATG"
+#line 1677 "VBNET.ATG"
pexpr = new XmlMemberAccessExpression(pexpr, XmlAxisType.Element, name, true);
} else if (StartOf(32)) {
IdentifierOrKeyword(
-#line 1680 "VBNET.ATG"
+#line 1678 "VBNET.ATG"
out name);
-#line 1681 "VBNET.ATG"
+#line 1679 "VBNET.ATG"
pexpr = new MemberReferenceExpression(pexpr, name);
- } else SynErr(275);
+ } else SynErr(276);
if (
-#line 1683 "VBNET.ATG"
+#line 1681 "VBNET.ATG"
la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
lexer.NextToken();
Expect(169);
TypeArgumentList(
-#line 1684 "VBNET.ATG"
+#line 1682 "VBNET.ATG"
((MemberReferenceExpression)pexpr).TypeArguments);
Expect(38);
}
} else if (la.kind == 29) {
lexer.NextToken();
IdentifierOrKeyword(
-#line 1686 "VBNET.ATG"
+#line 1684 "VBNET.ATG"
out name);
-#line 1686 "VBNET.ATG"
+#line 1684 "VBNET.ATG"
pexpr = new BinaryOperatorExpression(pexpr, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name));
} else if (la.kind == 27 || la.kind == 28) {
-#line 1687 "VBNET.ATG"
+#line 1685 "VBNET.ATG"
XmlAxisType type = XmlAxisType.Attribute; bool isXmlName = false;
if (la.kind == 28) {
lexer.NextToken();
} else if (la.kind == 27) {
lexer.NextToken();
-#line 1688 "VBNET.ATG"
+#line 1686 "VBNET.ATG"
type = XmlAxisType.Descendents;
- } else SynErr(276);
+ } else SynErr(277);
if (la.kind == 10) {
lexer.NextToken();
-#line 1688 "VBNET.ATG"
+#line 1686 "VBNET.ATG"
isXmlName = true;
}
IdentifierOrKeyword(
-#line 1688 "VBNET.ATG"
+#line 1686 "VBNET.ATG"
out name);
if (la.kind == 11) {
lexer.NextToken();
}
-#line 1689 "VBNET.ATG"
+#line 1687 "VBNET.ATG"
pexpr = new XmlMemberAccessExpression(pexpr, type, name, isXmlName);
} else {
InvocationExpression(
-#line 1690 "VBNET.ATG"
+#line 1688 "VBNET.ATG"
ref pexpr);
}
}
}
void SimpleNonInvocationExpression(
-#line 1694 "VBNET.ATG"
+#line 1692 "VBNET.ATG"
out Expression pexpr) {
-#line 1696 "VBNET.ATG"
+#line 1694 "VBNET.ATG"
Expression expr;
CollectionInitializerExpression cie;
TypeReference type = null;
@@ -3860,98 +3861,98 @@ out Expression pexpr) {
case 3: {
lexer.NextToken();
-#line 1705 "VBNET.ATG"
+#line 1703 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 4: {
lexer.NextToken();
-#line 1706 "VBNET.ATG"
+#line 1704 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 7: {
lexer.NextToken();
-#line 1707 "VBNET.ATG"
+#line 1705 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 6: {
lexer.NextToken();
-#line 1708 "VBNET.ATG"
+#line 1706 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 5: {
lexer.NextToken();
-#line 1709 "VBNET.ATG"
+#line 1707 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 9: {
lexer.NextToken();
-#line 1710 "VBNET.ATG"
+#line 1708 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 8: {
lexer.NextToken();
-#line 1711 "VBNET.ATG"
+#line 1709 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 217: {
lexer.NextToken();
-#line 1713 "VBNET.ATG"
+#line 1711 "VBNET.ATG"
pexpr = new PrimitiveExpression(true, "true");
break;
}
case 122: {
lexer.NextToken();
-#line 1714 "VBNET.ATG"
+#line 1712 "VBNET.ATG"
pexpr = new PrimitiveExpression(false, "false");
break;
}
case 165: {
lexer.NextToken();
-#line 1715 "VBNET.ATG"
+#line 1713 "VBNET.ATG"
pexpr = new PrimitiveExpression(null, "null");
break;
}
case 37: {
lexer.NextToken();
Expr(
-#line 1716 "VBNET.ATG"
+#line 1714 "VBNET.ATG"
out expr);
Expect(38);
-#line 1716 "VBNET.ATG"
+#line 1714 "VBNET.ATG"
pexpr = new ParenthesizedExpression(expr);
break;
}
case 2: case 58: case 62: case 64: case 65: case 66: case 67: case 70: case 87: case 98: case 104: case 107: case 116: case 121: case 126: case 133: case 139: case 143: case 146: case 147: case 170: case 176: case 178: case 184: case 203: case 212: case 213: case 223: case 224: case 230: {
Identifier();
-#line 1718 "VBNET.ATG"
+#line 1716 "VBNET.ATG"
pexpr = new IdentifierExpression(t.val);
pexpr.StartLocation = t.Location; pexpr.EndLocation = t.EndLocation;
if (
-#line 1721 "VBNET.ATG"
+#line 1719 "VBNET.ATG"
la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
lexer.NextToken();
Expect(169);
TypeArgumentList(
-#line 1722 "VBNET.ATG"
+#line 1720 "VBNET.ATG"
((IdentifierExpression)pexpr).TypeArguments);
Expect(38);
}
@@ -3959,51 +3960,51 @@ la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
}
case 68: case 71: case 82: case 99: case 100: case 109: case 141: case 151: case 168: case 196: case 201: case 202: case 208: case 221: case 222: case 225: {
-#line 1724 "VBNET.ATG"
+#line 1722 "VBNET.ATG"
string val = String.Empty;
if (StartOf(12)) {
PrimitiveTypeName(
-#line 1725 "VBNET.ATG"
+#line 1723 "VBNET.ATG"
out val);
} else if (la.kind == 168) {
lexer.NextToken();
-#line 1725 "VBNET.ATG"
+#line 1723 "VBNET.ATG"
val = "System.Object";
- } else SynErr(277);
+ } else SynErr(278);
-#line 1726 "VBNET.ATG"
+#line 1724 "VBNET.ATG"
pexpr = new TypeReferenceExpression(new TypeReference(val, true));
break;
}
case 153: {
lexer.NextToken();
-#line 1727 "VBNET.ATG"
+#line 1725 "VBNET.ATG"
pexpr = new ThisReferenceExpression();
break;
}
case 158: case 159: {
-#line 1728 "VBNET.ATG"
+#line 1726 "VBNET.ATG"
Expression retExpr = null;
if (la.kind == 158) {
lexer.NextToken();
-#line 1729 "VBNET.ATG"
+#line 1727 "VBNET.ATG"
retExpr = new BaseReferenceExpression();
} else if (la.kind == 159) {
lexer.NextToken();
-#line 1730 "VBNET.ATG"
+#line 1728 "VBNET.ATG"
retExpr = new ClassReferenceExpression();
- } else SynErr(278);
+ } else SynErr(279);
Expect(26);
IdentifierOrKeyword(
-#line 1732 "VBNET.ATG"
+#line 1730 "VBNET.ATG"
out name);
-#line 1732 "VBNET.ATG"
+#line 1730 "VBNET.ATG"
pexpr = new MemberReferenceExpression(retExpr, name);
break;
}
@@ -4012,86 +4013,86 @@ out name);
Expect(26);
Identifier();
-#line 1734 "VBNET.ATG"
+#line 1732 "VBNET.ATG"
type = new TypeReference(t.val ?? "");
-#line 1736 "VBNET.ATG"
+#line 1734 "VBNET.ATG"
type.IsGlobal = true;
-#line 1737 "VBNET.ATG"
+#line 1735 "VBNET.ATG"
pexpr = new TypeReferenceExpression(type);
break;
}
case 162: {
ObjectCreateExpression(
-#line 1738 "VBNET.ATG"
+#line 1736 "VBNET.ATG"
out expr);
-#line 1738 "VBNET.ATG"
+#line 1736 "VBNET.ATG"
pexpr = expr;
break;
}
case 35: {
CollectionInitializer(
-#line 1739 "VBNET.ATG"
+#line 1737 "VBNET.ATG"
out cie);
-#line 1739 "VBNET.ATG"
+#line 1737 "VBNET.ATG"
pexpr = cie;
break;
}
case 94: case 106: case 219: {
-#line 1741 "VBNET.ATG"
+#line 1739 "VBNET.ATG"
CastType castType = CastType.Cast;
if (la.kind == 106) {
lexer.NextToken();
} else if (la.kind == 94) {
lexer.NextToken();
-#line 1743 "VBNET.ATG"
+#line 1741 "VBNET.ATG"
castType = CastType.Conversion;
} else if (la.kind == 219) {
lexer.NextToken();
-#line 1744 "VBNET.ATG"
+#line 1742 "VBNET.ATG"
castType = CastType.TryCast;
- } else SynErr(279);
+ } else SynErr(280);
Expect(37);
Expr(
-#line 1746 "VBNET.ATG"
+#line 1744 "VBNET.ATG"
out expr);
Expect(22);
TypeName(
-#line 1746 "VBNET.ATG"
+#line 1744 "VBNET.ATG"
out type);
Expect(38);
-#line 1747 "VBNET.ATG"
+#line 1745 "VBNET.ATG"
pexpr = new CastExpression(type, expr, castType);
break;
}
case 76: case 77: case 78: case 79: case 80: case 81: case 83: case 85: case 86: case 90: case 91: case 92: case 93: case 95: case 96: case 97: {
CastTarget(
-#line 1748 "VBNET.ATG"
+#line 1746 "VBNET.ATG"
out type);
Expect(37);
Expr(
-#line 1748 "VBNET.ATG"
+#line 1746 "VBNET.ATG"
out expr);
Expect(38);
-#line 1748 "VBNET.ATG"
+#line 1746 "VBNET.ATG"
pexpr = new CastExpression(type, expr, CastType.PrimitiveConversion);
break;
}
case 57: {
lexer.NextToken();
Expr(
-#line 1749 "VBNET.ATG"
+#line 1747 "VBNET.ATG"
out expr);
-#line 1749 "VBNET.ATG"
+#line 1747 "VBNET.ATG"
pexpr = new AddressOfExpression(expr);
break;
}
@@ -4099,37 +4100,37 @@ out expr);
lexer.NextToken();
Expect(37);
GetTypeTypeName(
-#line 1750 "VBNET.ATG"
+#line 1748 "VBNET.ATG"
out type);
Expect(38);
-#line 1750 "VBNET.ATG"
+#line 1748 "VBNET.ATG"
pexpr = new TypeOfExpression(type);
break;
}
case 220: {
lexer.NextToken();
SimpleExpr(
-#line 1751 "VBNET.ATG"
+#line 1749 "VBNET.ATG"
out expr);
Expect(144);
TypeName(
-#line 1751 "VBNET.ATG"
+#line 1749 "VBNET.ATG"
out type);
-#line 1751 "VBNET.ATG"
+#line 1749 "VBNET.ATG"
pexpr = new TypeOfIsExpression(expr, type);
break;
}
case 135: {
ConditionalExpression(
-#line 1752 "VBNET.ATG"
+#line 1750 "VBNET.ATG"
out pexpr);
break;
}
case 10: case 16: case 17: case 18: case 19: {
XmlLiteralExpression(
-#line 1753 "VBNET.ATG"
+#line 1751 "VBNET.ATG"
out pexpr);
break;
}
@@ -4140,363 +4141,363 @@ out pexpr);
if (la.kind == 10) {
lexer.NextToken();
IdentifierOrKeyword(
-#line 1759 "VBNET.ATG"
+#line 1757 "VBNET.ATG"
out name);
Expect(11);
-#line 1760 "VBNET.ATG"
+#line 1758 "VBNET.ATG"
pexpr = new XmlMemberAccessExpression(null, XmlAxisType.Element, name, true);
} else if (StartOf(32)) {
IdentifierOrKeyword(
-#line 1761 "VBNET.ATG"
+#line 1759 "VBNET.ATG"
out name);
-#line 1762 "VBNET.ATG"
+#line 1760 "VBNET.ATG"
pexpr = new MemberReferenceExpression(null, name);
- } else SynErr(280);
+ } else SynErr(281);
} else if (la.kind == 29) {
lexer.NextToken();
IdentifierOrKeyword(
-#line 1764 "VBNET.ATG"
+#line 1762 "VBNET.ATG"
out name);
-#line 1764 "VBNET.ATG"
+#line 1762 "VBNET.ATG"
pexpr = new BinaryOperatorExpression(null, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name));
} else {
-#line 1765 "VBNET.ATG"
+#line 1763 "VBNET.ATG"
XmlAxisType axisType = XmlAxisType.Element; bool isXmlIdentifier = false;
if (la.kind == 27) {
lexer.NextToken();
-#line 1766 "VBNET.ATG"
+#line 1764 "VBNET.ATG"
axisType = XmlAxisType.Descendents;
} else if (la.kind == 28) {
lexer.NextToken();
-#line 1766 "VBNET.ATG"
+#line 1764 "VBNET.ATG"
axisType = XmlAxisType.Attribute;
- } else SynErr(281);
+ } else SynErr(282);
if (la.kind == 10) {
lexer.NextToken();
-#line 1767 "VBNET.ATG"
+#line 1765 "VBNET.ATG"
isXmlIdentifier = true;
}
IdentifierOrKeyword(
-#line 1767 "VBNET.ATG"
+#line 1765 "VBNET.ATG"
out name);
if (la.kind == 11) {
lexer.NextToken();
}
-#line 1768 "VBNET.ATG"
+#line 1766 "VBNET.ATG"
pexpr = new XmlMemberAccessExpression(null, axisType, name, isXmlIdentifier);
}
- } else SynErr(282);
+ } else SynErr(283);
}
void TypeArgumentList(
-#line 2743 "VBNET.ATG"
+#line 2741 "VBNET.ATG"
List typeArguments) {
-#line 2745 "VBNET.ATG"
+#line 2743 "VBNET.ATG"
TypeReference typeref;
TypeName(
-#line 2747 "VBNET.ATG"
+#line 2745 "VBNET.ATG"
out typeref);
-#line 2747 "VBNET.ATG"
+#line 2745 "VBNET.ATG"
if (typeref != null) typeArguments.Add(typeref);
while (la.kind == 22) {
lexer.NextToken();
TypeName(
-#line 2750 "VBNET.ATG"
+#line 2748 "VBNET.ATG"
out typeref);
-#line 2750 "VBNET.ATG"
+#line 2748 "VBNET.ATG"
if (typeref != null) typeArguments.Add(typeref);
}
}
void InvocationExpression(
-#line 1888 "VBNET.ATG"
+#line 1886 "VBNET.ATG"
ref Expression pexpr) {
-#line 1889 "VBNET.ATG"
+#line 1887 "VBNET.ATG"
List parameters = null;
Expect(37);
-#line 1891 "VBNET.ATG"
+#line 1889 "VBNET.ATG"
Location start = t.Location;
ArgumentList(
-#line 1892 "VBNET.ATG"
+#line 1890 "VBNET.ATG"
out parameters);
Expect(38);
-#line 1895 "VBNET.ATG"
+#line 1893 "VBNET.ATG"
pexpr = new InvocationExpression(pexpr, parameters);
-#line 1897 "VBNET.ATG"
+#line 1895 "VBNET.ATG"
pexpr.StartLocation = start; pexpr.EndLocation = t.Location;
}
void PrimitiveTypeName(
-#line 3570 "VBNET.ATG"
+#line 3568 "VBNET.ATG"
out string type) {
-#line 3571 "VBNET.ATG"
+#line 3569 "VBNET.ATG"
type = String.Empty;
switch (la.kind) {
case 68: {
lexer.NextToken();
-#line 3572 "VBNET.ATG"
+#line 3570 "VBNET.ATG"
type = "System.Boolean";
break;
}
case 99: {
lexer.NextToken();
-#line 3573 "VBNET.ATG"
+#line 3571 "VBNET.ATG"
type = "System.DateTime";
break;
}
case 82: {
lexer.NextToken();
-#line 3574 "VBNET.ATG"
+#line 3572 "VBNET.ATG"
type = "System.Char";
break;
}
case 208: {
lexer.NextToken();
-#line 3575 "VBNET.ATG"
+#line 3573 "VBNET.ATG"
type = "System.String";
break;
}
case 100: {
lexer.NextToken();
-#line 3576 "VBNET.ATG"
+#line 3574 "VBNET.ATG"
type = "System.Decimal";
break;
}
case 71: {
lexer.NextToken();
-#line 3577 "VBNET.ATG"
+#line 3575 "VBNET.ATG"
type = "System.Byte";
break;
}
case 201: {
lexer.NextToken();
-#line 3578 "VBNET.ATG"
+#line 3576 "VBNET.ATG"
type = "System.Int16";
break;
}
case 141: {
lexer.NextToken();
-#line 3579 "VBNET.ATG"
+#line 3577 "VBNET.ATG"
type = "System.Int32";
break;
}
case 151: {
lexer.NextToken();
-#line 3580 "VBNET.ATG"
+#line 3578 "VBNET.ATG"
type = "System.Int64";
break;
}
case 202: {
lexer.NextToken();
-#line 3581 "VBNET.ATG"
+#line 3579 "VBNET.ATG"
type = "System.Single";
break;
}
case 109: {
lexer.NextToken();
-#line 3582 "VBNET.ATG"
+#line 3580 "VBNET.ATG"
type = "System.Double";
break;
}
case 221: {
lexer.NextToken();
-#line 3583 "VBNET.ATG"
+#line 3581 "VBNET.ATG"
type = "System.UInt32";
break;
}
case 222: {
lexer.NextToken();
-#line 3584 "VBNET.ATG"
+#line 3582 "VBNET.ATG"
type = "System.UInt64";
break;
}
case 225: {
lexer.NextToken();
-#line 3585 "VBNET.ATG"
+#line 3583 "VBNET.ATG"
type = "System.UInt16";
break;
}
case 196: {
lexer.NextToken();
-#line 3586 "VBNET.ATG"
+#line 3584 "VBNET.ATG"
type = "System.SByte";
break;
}
- default: SynErr(283); break;
+ default: SynErr(284); break;
}
}
void CastTarget(
-#line 1902 "VBNET.ATG"
+#line 1900 "VBNET.ATG"
out TypeReference type) {
-#line 1904 "VBNET.ATG"
+#line 1902 "VBNET.ATG"
type = null;
switch (la.kind) {
case 76: {
lexer.NextToken();
-#line 1906 "VBNET.ATG"
+#line 1904 "VBNET.ATG"
type = new TypeReference("System.Boolean", true);
break;
}
case 77: {
lexer.NextToken();
-#line 1907 "VBNET.ATG"
+#line 1905 "VBNET.ATG"
type = new TypeReference("System.Byte", true);
break;
}
case 90: {
lexer.NextToken();
-#line 1908 "VBNET.ATG"
+#line 1906 "VBNET.ATG"
type = new TypeReference("System.SByte", true);
break;
}
case 78: {
lexer.NextToken();
-#line 1909 "VBNET.ATG"
+#line 1907 "VBNET.ATG"
type = new TypeReference("System.Char", true);
break;
}
case 79: {
lexer.NextToken();
-#line 1910 "VBNET.ATG"
+#line 1908 "VBNET.ATG"
type = new TypeReference("System.DateTime", true);
break;
}
case 81: {
lexer.NextToken();
-#line 1911 "VBNET.ATG"
+#line 1909 "VBNET.ATG"
type = new TypeReference("System.Decimal", true);
break;
}
case 80: {
lexer.NextToken();
-#line 1912 "VBNET.ATG"
+#line 1910 "VBNET.ATG"
type = new TypeReference("System.Double", true);
break;
}
case 91: {
lexer.NextToken();
-#line 1913 "VBNET.ATG"
+#line 1911 "VBNET.ATG"
type = new TypeReference("System.Int16", true);
break;
}
case 83: {
lexer.NextToken();
-#line 1914 "VBNET.ATG"
+#line 1912 "VBNET.ATG"
type = new TypeReference("System.Int32", true);
break;
}
case 85: {
lexer.NextToken();
-#line 1915 "VBNET.ATG"
+#line 1913 "VBNET.ATG"
type = new TypeReference("System.Int64", true);
break;
}
case 97: {
lexer.NextToken();
-#line 1916 "VBNET.ATG"
+#line 1914 "VBNET.ATG"
type = new TypeReference("System.UInt16", true);
break;
}
case 95: {
lexer.NextToken();
-#line 1917 "VBNET.ATG"
+#line 1915 "VBNET.ATG"
type = new TypeReference("System.UInt32", true);
break;
}
case 96: {
lexer.NextToken();
-#line 1918 "VBNET.ATG"
+#line 1916 "VBNET.ATG"
type = new TypeReference("System.UInt64", true);
break;
}
case 86: {
lexer.NextToken();
-#line 1919 "VBNET.ATG"
+#line 1917 "VBNET.ATG"
type = new TypeReference("System.Object", true);
break;
}
case 92: {
lexer.NextToken();
-#line 1920 "VBNET.ATG"
+#line 1918 "VBNET.ATG"
type = new TypeReference("System.Single", true);
break;
}
case 93: {
lexer.NextToken();
-#line 1921 "VBNET.ATG"
+#line 1919 "VBNET.ATG"
type = new TypeReference("System.String", true);
break;
}
- default: SynErr(284); break;
+ default: SynErr(285); break;
}
}
void GetTypeTypeName(
-#line 2642 "VBNET.ATG"
+#line 2640 "VBNET.ATG"
out TypeReference typeref) {
-#line 2643 "VBNET.ATG"
+#line 2641 "VBNET.ATG"
ArrayList rank = null;
NonArrayTypeName(
-#line 2645 "VBNET.ATG"
+#line 2643 "VBNET.ATG"
out typeref, true);
ArrayTypeModifiers(
-#line 2646 "VBNET.ATG"
+#line 2644 "VBNET.ATG"
out rank);
-#line 2647 "VBNET.ATG"
+#line 2645 "VBNET.ATG"
if (rank != null && typeref != null) {
typeref.RankSpecifier = (int[])rank.ToArray(typeof(int));
}
@@ -4504,10 +4505,10 @@ out rank);
}
void ConditionalExpression(
-#line 1854 "VBNET.ATG"
+#line 1852 "VBNET.ATG"
out Expression expr) {
-#line 1856 "VBNET.ATG"
+#line 1854 "VBNET.ATG"
ConditionalExpression conditionalExpression = new ConditionalExpression();
BinaryOperatorExpression binaryOperatorExpression = new BinaryOperatorExpression();
conditionalExpression.StartLocation = binaryOperatorExpression.StartLocation = la.Location;
@@ -4519,21 +4520,21 @@ out Expression expr) {
Expect(135);
Expect(37);
Expr(
-#line 1865 "VBNET.ATG"
+#line 1863 "VBNET.ATG"
out condition);
Expect(22);
Expr(
-#line 1865 "VBNET.ATG"
+#line 1863 "VBNET.ATG"
out trueExpr);
if (la.kind == 22) {
lexer.NextToken();
Expr(
-#line 1865 "VBNET.ATG"
+#line 1863 "VBNET.ATG"
out falseExpr);
}
Expect(38);
-#line 1867 "VBNET.ATG"
+#line 1865 "VBNET.ATG"
if(falseExpr != null)
{
conditionalExpression.Condition = condition;
@@ -4556,50 +4557,50 @@ out falseExpr);
}
void XmlLiteralExpression(
-#line 1774 "VBNET.ATG"
+#line 1772 "VBNET.ATG"
out Expression pexpr) {
-#line 1776 "VBNET.ATG"
+#line 1774 "VBNET.ATG"
List exprs = new List();
XmlExpression currentExpression = null;
if (StartOf(35)) {
XmlContentExpression(
-#line 1781 "VBNET.ATG"
+#line 1779 "VBNET.ATG"
exprs);
while (StartOf(35)) {
XmlContentExpression(
-#line 1781 "VBNET.ATG"
+#line 1779 "VBNET.ATG"
exprs);
}
if (la.kind == 10) {
XmlElement(
-#line 1781 "VBNET.ATG"
+#line 1779 "VBNET.ATG"
out currentExpression);
-#line 1781 "VBNET.ATG"
+#line 1779 "VBNET.ATG"
exprs.Add(currentExpression);
while (StartOf(35)) {
XmlContentExpression(
-#line 1781 "VBNET.ATG"
+#line 1779 "VBNET.ATG"
exprs);
}
}
} else if (la.kind == 10) {
XmlElement(
-#line 1783 "VBNET.ATG"
+#line 1781 "VBNET.ATG"
out currentExpression);
-#line 1783 "VBNET.ATG"
+#line 1781 "VBNET.ATG"
exprs.Add(currentExpression);
while (StartOf(35)) {
XmlContentExpression(
-#line 1783 "VBNET.ATG"
+#line 1781 "VBNET.ATG"
exprs);
}
- } else SynErr(285);
+ } else SynErr(286);
-#line 1786 "VBNET.ATG"
+#line 1784 "VBNET.ATG"
if (exprs.Count > 1) {
pexpr = new XmlDocumentExpression() { Expressions = exprs };
} else {
@@ -4609,34 +4610,34 @@ exprs);
}
void XmlContentExpression(
-#line 1794 "VBNET.ATG"
+#line 1792 "VBNET.ATG"
List exprs) {
-#line 1795 "VBNET.ATG"
+#line 1793 "VBNET.ATG"
XmlContentExpression expr = null;
if (la.kind == 16) {
lexer.NextToken();
-#line 1797 "VBNET.ATG"
+#line 1795 "VBNET.ATG"
expr = new XmlContentExpression(t.val, XmlContentType.Text);
} else if (la.kind == 18) {
lexer.NextToken();
-#line 1798 "VBNET.ATG"
+#line 1796 "VBNET.ATG"
expr = new XmlContentExpression(t.val, XmlContentType.CData);
} else if (la.kind == 17) {
lexer.NextToken();
-#line 1799 "VBNET.ATG"
+#line 1797 "VBNET.ATG"
expr = new XmlContentExpression(t.val, XmlContentType.Comment);
} else if (la.kind == 19) {
lexer.NextToken();
-#line 1800 "VBNET.ATG"
+#line 1798 "VBNET.ATG"
expr = new XmlContentExpression(t.val, XmlContentType.ProcessingInstruction);
- } else SynErr(286);
+ } else SynErr(287);
-#line 1803 "VBNET.ATG"
+#line 1801 "VBNET.ATG"
expr.StartLocation = t.Location;
expr.EndLocation = t.EndLocation;
exprs.Add(expr);
@@ -4644,54 +4645,54 @@ List exprs) {
}
void XmlElement(
-#line 1829 "VBNET.ATG"
+#line 1827 "VBNET.ATG"
out XmlExpression expr) {
-#line 1830 "VBNET.ATG"
+#line 1828 "VBNET.ATG"
XmlElementExpression el = new XmlElementExpression();
Expect(10);
-#line 1833 "VBNET.ATG"
+#line 1831 "VBNET.ATG"
el.StartLocation = t.Location;
if (la.kind == 12) {
lexer.NextToken();
-#line 1834 "VBNET.ATG"
+#line 1832 "VBNET.ATG"
Expression innerExpression;
Expr(
-#line 1834 "VBNET.ATG"
+#line 1832 "VBNET.ATG"
out innerExpression);
Expect(13);
-#line 1835 "VBNET.ATG"
+#line 1833 "VBNET.ATG"
el.NameExpression = new XmlEmbeddedExpression() { InlineVBExpression = innerExpression };
} else if (StartOf(4)) {
Identifier();
-#line 1836 "VBNET.ATG"
+#line 1834 "VBNET.ATG"
el.XmlName = t.val;
- } else SynErr(287);
+ } else SynErr(288);
while (StartOf(36)) {
XmlAttribute(
-#line 1836 "VBNET.ATG"
+#line 1834 "VBNET.ATG"
el.Attributes);
}
if (la.kind == 14) {
lexer.NextToken();
-#line 1837 "VBNET.ATG"
+#line 1835 "VBNET.ATG"
el.EndLocation = t.EndLocation;
} else if (la.kind == 11) {
lexer.NextToken();
while (StartOf(37)) {
-#line 1837 "VBNET.ATG"
+#line 1835 "VBNET.ATG"
XmlExpression child;
XmlNestedContent(
-#line 1837 "VBNET.ATG"
+#line 1835 "VBNET.ATG"
out child);
-#line 1837 "VBNET.ATG"
+#line 1835 "VBNET.ATG"
el.Children.Add(child);
}
Expect(15);
@@ -4700,73 +4701,73 @@ out child);
}
Expect(11);
-#line 1837 "VBNET.ATG"
+#line 1835 "VBNET.ATG"
el.EndLocation = t.EndLocation;
- } else SynErr(288);
+ } else SynErr(289);
-#line 1839 "VBNET.ATG"
+#line 1837 "VBNET.ATG"
expr = el;
}
void XmlNestedContent(
-#line 1809 "VBNET.ATG"
+#line 1807 "VBNET.ATG"
out XmlExpression expr) {
-#line 1810 "VBNET.ATG"
+#line 1808 "VBNET.ATG"
XmlExpression tmpExpr = null; Location start = la.Location;
switch (la.kind) {
case 16: {
lexer.NextToken();
-#line 1813 "VBNET.ATG"
+#line 1811 "VBNET.ATG"
tmpExpr = new XmlContentExpression(t.val, XmlContentType.Text);
break;
}
case 18: {
lexer.NextToken();
-#line 1814 "VBNET.ATG"
+#line 1812 "VBNET.ATG"
tmpExpr = new XmlContentExpression(t.val, XmlContentType.CData);
break;
}
case 17: {
lexer.NextToken();
-#line 1815 "VBNET.ATG"
+#line 1813 "VBNET.ATG"
tmpExpr = new XmlContentExpression(t.val, XmlContentType.Comment);
break;
}
case 19: {
lexer.NextToken();
-#line 1816 "VBNET.ATG"
+#line 1814 "VBNET.ATG"
tmpExpr = new XmlContentExpression(t.val, XmlContentType.ProcessingInstruction);
break;
}
case 12: {
lexer.NextToken();
-#line 1817 "VBNET.ATG"
+#line 1815 "VBNET.ATG"
Expression innerExpression;
Expr(
-#line 1817 "VBNET.ATG"
+#line 1815 "VBNET.ATG"
out innerExpression);
Expect(13);
-#line 1817 "VBNET.ATG"
+#line 1815 "VBNET.ATG"
tmpExpr = new XmlEmbeddedExpression() { InlineVBExpression = innerExpression };
break;
}
case 10: {
XmlElement(
-#line 1818 "VBNET.ATG"
+#line 1816 "VBNET.ATG"
out tmpExpr);
break;
}
- default: SynErr(289); break;
+ default: SynErr(290); break;
}
-#line 1821 "VBNET.ATG"
+#line 1819 "VBNET.ATG"
if (tmpExpr.StartLocation.IsEmpty)
tmpExpr.StartLocation = start;
if (tmpExpr.EndLocation.IsEmpty)
@@ -4776,393 +4777,393 @@ out tmpExpr);
}
void XmlAttribute(
-#line 1842 "VBNET.ATG"
+#line 1840 "VBNET.ATG"
List attrs) {
-#line 1843 "VBNET.ATG"
+#line 1841 "VBNET.ATG"
Location start = la.Location;
if (StartOf(4)) {
Identifier();
-#line 1845 "VBNET.ATG"
+#line 1843 "VBNET.ATG"
string name = t.val;
Expect(20);
-#line 1846 "VBNET.ATG"
+#line 1844 "VBNET.ATG"
string literalValue = null; Expression expressionValue = null; bool useDoubleQuotes = false;
if (la.kind == 3) {
lexer.NextToken();
-#line 1847 "VBNET.ATG"
+#line 1845 "VBNET.ATG"
literalValue = t.literalValue.ToString(); useDoubleQuotes = t.val[0] == '"';
} else if (la.kind == 12) {
lexer.NextToken();
Expr(
-#line 1847 "VBNET.ATG"
+#line 1845 "VBNET.ATG"
out expressionValue);
Expect(13);
- } else SynErr(290);
+ } else SynErr(291);
-#line 1848 "VBNET.ATG"
+#line 1846 "VBNET.ATG"
attrs.Add(new XmlAttributeExpression() { Name = name, ExpressionValue = expressionValue, LiteralValue = literalValue, UseDoubleQuotes = useDoubleQuotes, StartLocation = start, EndLocation = t.EndLocation });
} else if (la.kind == 12) {
lexer.NextToken();
-#line 1850 "VBNET.ATG"
+#line 1848 "VBNET.ATG"
Expression innerExpression;
Expr(
-#line 1850 "VBNET.ATG"
+#line 1848 "VBNET.ATG"
out innerExpression);
Expect(13);
-#line 1851 "VBNET.ATG"
+#line 1849 "VBNET.ATG"
attrs.Add(new XmlEmbeddedExpression() { InlineVBExpression = innerExpression, StartLocation = start, EndLocation = t.EndLocation });
- } else SynErr(291);
+ } else SynErr(292);
}
void ArgumentList(
-#line 2574 "VBNET.ATG"
+#line 2572 "VBNET.ATG"
out List arguments) {
-#line 2576 "VBNET.ATG"
+#line 2574 "VBNET.ATG"
arguments = new List();
Expression expr = null;
if (StartOf(29)) {
Argument(
-#line 2579 "VBNET.ATG"
+#line 2577 "VBNET.ATG"
out expr);
}
while (la.kind == 22) {
lexer.NextToken();
-#line 2580 "VBNET.ATG"
+#line 2578 "VBNET.ATG"
arguments.Add(expr ?? Expression.Null); expr = null;
if (StartOf(29)) {
Argument(
-#line 2581 "VBNET.ATG"
+#line 2579 "VBNET.ATG"
out expr);
}
-#line 2582 "VBNET.ATG"
+#line 2580 "VBNET.ATG"
if (expr == null) expr = Expression.Null;
}
-#line 2584 "VBNET.ATG"
+#line 2582 "VBNET.ATG"
if (expr != null) arguments.Add(expr);
}
void ConjunctionExpr(
-#line 1940 "VBNET.ATG"
+#line 1938 "VBNET.ATG"
out Expression outExpr) {
-#line 1942 "VBNET.ATG"
+#line 1940 "VBNET.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
NotExpr(
-#line 1945 "VBNET.ATG"
+#line 1943 "VBNET.ATG"
out outExpr);
while (la.kind == 60 || la.kind == 61) {
if (la.kind == 60) {
lexer.NextToken();
-#line 1948 "VBNET.ATG"
+#line 1946 "VBNET.ATG"
op = BinaryOperatorType.BitwiseAnd;
} else {
lexer.NextToken();
-#line 1949 "VBNET.ATG"
+#line 1947 "VBNET.ATG"
op = BinaryOperatorType.LogicalAnd;
}
NotExpr(
-#line 1951 "VBNET.ATG"
+#line 1949 "VBNET.ATG"
out expr);
-#line 1951 "VBNET.ATG"
+#line 1949 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
void NotExpr(
-#line 1955 "VBNET.ATG"
+#line 1953 "VBNET.ATG"
out Expression outExpr) {
-#line 1956 "VBNET.ATG"
+#line 1954 "VBNET.ATG"
UnaryOperatorType uop = UnaryOperatorType.None;
while (la.kind == 164) {
lexer.NextToken();
-#line 1957 "VBNET.ATG"
+#line 1955 "VBNET.ATG"
uop = UnaryOperatorType.Not;
}
ComparisonExpr(
-#line 1958 "VBNET.ATG"
+#line 1956 "VBNET.ATG"
out outExpr);
-#line 1959 "VBNET.ATG"
+#line 1957 "VBNET.ATG"
if (uop != UnaryOperatorType.None)
outExpr = new UnaryOperatorExpression(outExpr, uop);
}
void ComparisonExpr(
-#line 1964 "VBNET.ATG"
+#line 1962 "VBNET.ATG"
out Expression outExpr) {
-#line 1966 "VBNET.ATG"
+#line 1964 "VBNET.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
ShiftExpr(
-#line 1969 "VBNET.ATG"
+#line 1967 "VBNET.ATG"
out outExpr);
while (StartOf(39)) {
switch (la.kind) {
case 40: {
lexer.NextToken();
-#line 1972 "VBNET.ATG"
+#line 1970 "VBNET.ATG"
op = BinaryOperatorType.LessThan;
break;
}
case 39: {
lexer.NextToken();
-#line 1973 "VBNET.ATG"
+#line 1971 "VBNET.ATG"
op = BinaryOperatorType.GreaterThan;
break;
}
case 43: {
lexer.NextToken();
-#line 1974 "VBNET.ATG"
+#line 1972 "VBNET.ATG"
op = BinaryOperatorType.LessThanOrEqual;
break;
}
case 42: {
lexer.NextToken();
-#line 1975 "VBNET.ATG"
+#line 1973 "VBNET.ATG"
op = BinaryOperatorType.GreaterThanOrEqual;
break;
}
case 41: {
lexer.NextToken();
-#line 1976 "VBNET.ATG"
+#line 1974 "VBNET.ATG"
op = BinaryOperatorType.InEquality;
break;
}
case 20: {
lexer.NextToken();
-#line 1977 "VBNET.ATG"
+#line 1975 "VBNET.ATG"
op = BinaryOperatorType.Equality;
break;
}
case 150: {
lexer.NextToken();
-#line 1978 "VBNET.ATG"
+#line 1976 "VBNET.ATG"
op = BinaryOperatorType.Like;
break;
}
case 144: {
lexer.NextToken();
-#line 1979 "VBNET.ATG"
+#line 1977 "VBNET.ATG"
op = BinaryOperatorType.ReferenceEquality;
break;
}
case 145: {
lexer.NextToken();
-#line 1980 "VBNET.ATG"
+#line 1978 "VBNET.ATG"
op = BinaryOperatorType.ReferenceInequality;
break;
}
}
if (StartOf(40)) {
ShiftExpr(
-#line 1983 "VBNET.ATG"
+#line 1981 "VBNET.ATG"
out expr);
-#line 1983 "VBNET.ATG"
+#line 1981 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
} else if (la.kind == 164) {
lexer.NextToken();
ShiftExpr(
-#line 1986 "VBNET.ATG"
+#line 1984 "VBNET.ATG"
out expr);
-#line 1986 "VBNET.ATG"
+#line 1984 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, new UnaryOperatorExpression(expr, UnaryOperatorType.Not));
- } else SynErr(292);
+ } else SynErr(293);
}
}
void ShiftExpr(
-#line 1991 "VBNET.ATG"
+#line 1989 "VBNET.ATG"
out Expression outExpr) {
-#line 1993 "VBNET.ATG"
+#line 1991 "VBNET.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
ConcatenationExpr(
-#line 1996 "VBNET.ATG"
+#line 1994 "VBNET.ATG"
out outExpr);
while (la.kind == 44 || la.kind == 45) {
if (la.kind == 44) {
lexer.NextToken();
-#line 1999 "VBNET.ATG"
+#line 1997 "VBNET.ATG"
op = BinaryOperatorType.ShiftLeft;
} else {
lexer.NextToken();
-#line 2000 "VBNET.ATG"
+#line 1998 "VBNET.ATG"
op = BinaryOperatorType.ShiftRight;
}
ConcatenationExpr(
-#line 2002 "VBNET.ATG"
+#line 2000 "VBNET.ATG"
out expr);
-#line 2002 "VBNET.ATG"
+#line 2000 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
void ConcatenationExpr(
-#line 2006 "VBNET.ATG"
+#line 2004 "VBNET.ATG"
out Expression outExpr) {
-#line 2007 "VBNET.ATG"
+#line 2005 "VBNET.ATG"
Expression expr;
AdditiveExpr(
-#line 2009 "VBNET.ATG"
+#line 2007 "VBNET.ATG"
out outExpr);
while (la.kind == 23) {
lexer.NextToken();
AdditiveExpr(
-#line 2009 "VBNET.ATG"
+#line 2007 "VBNET.ATG"
out expr);
-#line 2009 "VBNET.ATG"
+#line 2007 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Concat, expr);
}
}
void AdditiveExpr(
-#line 2012 "VBNET.ATG"
+#line 2010 "VBNET.ATG"
out Expression outExpr) {
-#line 2014 "VBNET.ATG"
+#line 2012 "VBNET.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
ModuloExpr(
-#line 2017 "VBNET.ATG"
+#line 2015 "VBNET.ATG"
out outExpr);
while (la.kind == 30 || la.kind == 31) {
if (la.kind == 31) {
lexer.NextToken();
-#line 2020 "VBNET.ATG"
+#line 2018 "VBNET.ATG"
op = BinaryOperatorType.Add;
} else {
lexer.NextToken();
-#line 2021 "VBNET.ATG"
+#line 2019 "VBNET.ATG"
op = BinaryOperatorType.Subtract;
}
ModuloExpr(
-#line 2023 "VBNET.ATG"
+#line 2021 "VBNET.ATG"
out expr);
-#line 2023 "VBNET.ATG"
+#line 2021 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
void ModuloExpr(
-#line 2027 "VBNET.ATG"
+#line 2025 "VBNET.ATG"
out Expression outExpr) {
-#line 2028 "VBNET.ATG"
+#line 2026 "VBNET.ATG"
Expression expr;
IntegerDivisionExpr(
-#line 2030 "VBNET.ATG"
+#line 2028 "VBNET.ATG"
out outExpr);
while (la.kind == 154) {
lexer.NextToken();
IntegerDivisionExpr(
-#line 2030 "VBNET.ATG"
+#line 2028 "VBNET.ATG"
out expr);
-#line 2030 "VBNET.ATG"
+#line 2028 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Modulus, expr);
}
}
void IntegerDivisionExpr(
-#line 2033 "VBNET.ATG"
+#line 2031 "VBNET.ATG"
out Expression outExpr) {
-#line 2034 "VBNET.ATG"
+#line 2032 "VBNET.ATG"
Expression expr;
MultiplicativeExpr(
-#line 2036 "VBNET.ATG"
+#line 2034 "VBNET.ATG"
out outExpr);
while (la.kind == 25) {
lexer.NextToken();
MultiplicativeExpr(
-#line 2036 "VBNET.ATG"
+#line 2034 "VBNET.ATG"
out expr);
-#line 2036 "VBNET.ATG"
+#line 2034 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.DivideInteger, expr);
}
}
void MultiplicativeExpr(
-#line 2039 "VBNET.ATG"
+#line 2037 "VBNET.ATG"
out Expression outExpr) {
-#line 2041 "VBNET.ATG"
+#line 2039 "VBNET.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
UnaryExpr(
-#line 2044 "VBNET.ATG"
+#line 2042 "VBNET.ATG"
out outExpr);
while (la.kind == 24 || la.kind == 34) {
if (la.kind == 34) {
lexer.NextToken();
-#line 2047 "VBNET.ATG"
+#line 2045 "VBNET.ATG"
op = BinaryOperatorType.Multiply;
} else {
lexer.NextToken();
-#line 2048 "VBNET.ATG"
+#line 2046 "VBNET.ATG"
op = BinaryOperatorType.Divide;
}
UnaryExpr(
-#line 2050 "VBNET.ATG"
+#line 2048 "VBNET.ATG"
out expr);
-#line 2050 "VBNET.ATG"
+#line 2048 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
void UnaryExpr(
-#line 2054 "VBNET.ATG"
+#line 2052 "VBNET.ATG"
out Expression uExpr) {
-#line 2056 "VBNET.ATG"
+#line 2054 "VBNET.ATG"
Expression expr;
UnaryOperatorType uop = UnaryOperatorType.None;
bool isUOp = false;
@@ -5171,25 +5172,25 @@ out Expression uExpr) {
if (la.kind == 31) {
lexer.NextToken();
-#line 2060 "VBNET.ATG"
+#line 2058 "VBNET.ATG"
uop = UnaryOperatorType.Plus; isUOp = true;
} else if (la.kind == 30) {
lexer.NextToken();
-#line 2061 "VBNET.ATG"
+#line 2059 "VBNET.ATG"
uop = UnaryOperatorType.Minus; isUOp = true;
} else {
lexer.NextToken();
-#line 2062 "VBNET.ATG"
+#line 2060 "VBNET.ATG"
uop = UnaryOperatorType.Dereference; isUOp = true;
}
}
ExponentiationExpr(
-#line 2064 "VBNET.ATG"
+#line 2062 "VBNET.ATG"
out expr);
-#line 2066 "VBNET.ATG"
+#line 2064 "VBNET.ATG"
if (isUOp) {
uExpr = new UnaryOperatorExpression(expr, uop);
} else {
@@ -5199,107 +5200,107 @@ out expr);
}
void ExponentiationExpr(
-#line 2074 "VBNET.ATG"
+#line 2072 "VBNET.ATG"
out Expression outExpr) {
-#line 2075 "VBNET.ATG"
+#line 2073 "VBNET.ATG"
Expression expr;
SimpleExpr(
-#line 2077 "VBNET.ATG"
+#line 2075 "VBNET.ATG"
out outExpr);
while (la.kind == 32) {
lexer.NextToken();
SimpleExpr(
-#line 2077 "VBNET.ATG"
+#line 2075 "VBNET.ATG"
out expr);
-#line 2077 "VBNET.ATG"
+#line 2075 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Power, expr);
}
}
void NormalOrReDimArgumentList(
-#line 2588 "VBNET.ATG"
+#line 2586 "VBNET.ATG"
out List arguments, out bool canBeNormal, out bool canBeRedim) {
-#line 2590 "VBNET.ATG"
+#line 2588 "VBNET.ATG"
arguments = new List();
canBeNormal = true; canBeRedim = !IsNamedAssign();
Expression expr = null;
if (StartOf(29)) {
Argument(
-#line 2595 "VBNET.ATG"
+#line 2593 "VBNET.ATG"
out expr);
if (la.kind == 216) {
lexer.NextToken();
-#line 2596 "VBNET.ATG"
+#line 2594 "VBNET.ATG"
EnsureIsZero(expr); canBeNormal = false;
Expr(
-#line 2597 "VBNET.ATG"
+#line 2595 "VBNET.ATG"
out expr);
}
}
while (la.kind == 22) {
lexer.NextToken();
-#line 2600 "VBNET.ATG"
+#line 2598 "VBNET.ATG"
if (expr == null) canBeRedim = false;
-#line 2601 "VBNET.ATG"
+#line 2599 "VBNET.ATG"
arguments.Add(expr ?? Expression.Null); expr = null;
-#line 2602 "VBNET.ATG"
+#line 2600 "VBNET.ATG"
canBeRedim &= !IsNamedAssign();
if (StartOf(29)) {
Argument(
-#line 2603 "VBNET.ATG"
+#line 2601 "VBNET.ATG"
out expr);
if (la.kind == 216) {
lexer.NextToken();
-#line 2604 "VBNET.ATG"
+#line 2602 "VBNET.ATG"
EnsureIsZero(expr); canBeNormal = false;
Expr(
-#line 2605 "VBNET.ATG"
+#line 2603 "VBNET.ATG"
out expr);
}
}
-#line 2607 "VBNET.ATG"
+#line 2605 "VBNET.ATG"
if (expr == null) { canBeRedim = false; expr = Expression.Null; }
}
-#line 2609 "VBNET.ATG"
+#line 2607 "VBNET.ATG"
if (expr != null) arguments.Add(expr); else canBeRedim = false;
}
void ArrayTypeModifiers(
-#line 2716 "VBNET.ATG"
+#line 2714 "VBNET.ATG"
out ArrayList arrayModifiers) {
-#line 2718 "VBNET.ATG"
+#line 2716 "VBNET.ATG"
arrayModifiers = new ArrayList();
int i = 0;
while (
-#line 2721 "VBNET.ATG"
+#line 2719 "VBNET.ATG"
IsDims()) {
Expect(37);
if (la.kind == 22 || la.kind == 38) {
RankList(
-#line 2723 "VBNET.ATG"
+#line 2721 "VBNET.ATG"
out i);
}
-#line 2725 "VBNET.ATG"
+#line 2723 "VBNET.ATG"
arrayModifiers.Add(i);
Expect(38);
}
-#line 2730 "VBNET.ATG"
+#line 2728 "VBNET.ATG"
if(arrayModifiers.Count == 0) {
arrayModifiers = null;
}
@@ -5307,10 +5308,10 @@ out i);
}
void MemberInitializer(
-#line 2555 "VBNET.ATG"
+#line 2553 "VBNET.ATG"
out MemberInitializerExpression memberInitializer) {
-#line 2557 "VBNET.ATG"
+#line 2555 "VBNET.ATG"
memberInitializer = new MemberInitializerExpression();
memberInitializer.StartLocation = la.Location;
Expression initExpr = null;
@@ -5320,19 +5321,19 @@ out MemberInitializerExpression memberInitializer) {
if (la.kind == 147) {
lexer.NextToken();
-#line 2563 "VBNET.ATG"
+#line 2561 "VBNET.ATG"
isKey = true;
}
Expect(26);
IdentifierOrKeyword(
-#line 2564 "VBNET.ATG"
+#line 2562 "VBNET.ATG"
out name);
Expect(20);
Expr(
-#line 2564 "VBNET.ATG"
+#line 2562 "VBNET.ATG"
out initExpr);
-#line 2566 "VBNET.ATG"
+#line 2564 "VBNET.ATG"
memberInitializer.Name = name;
memberInitializer.Expression = initExpr;
memberInitializer.IsKey = isKey;
@@ -5341,10 +5342,10 @@ out initExpr);
}
void SubLambdaExpression(
-#line 2160 "VBNET.ATG"
+#line 2158 "VBNET.ATG"
out LambdaExpression lambda) {
-#line 2162 "VBNET.ATG"
+#line 2160 "VBNET.ATG"
lambda = new LambdaExpression();
lambda.ReturnType = new TypeReference("System.Void", true);
Expression inner = null;
@@ -5356,7 +5357,7 @@ out LambdaExpression lambda) {
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 2169 "VBNET.ATG"
+#line 2167 "VBNET.ATG"
lambda.Parameters);
}
Expect(38);
@@ -5364,19 +5365,19 @@ lambda.Parameters);
if (StartOf(41)) {
if (StartOf(29)) {
Expr(
-#line 2172 "VBNET.ATG"
+#line 2170 "VBNET.ATG"
out inner);
-#line 2174 "VBNET.ATG"
+#line 2172 "VBNET.ATG"
lambda.ExpressionBody = inner;
lambda.EndLocation = t.EndLocation; // la.Location?
} else {
EmbeddedStatement(
-#line 2178 "VBNET.ATG"
+#line 2176 "VBNET.ATG"
out statement);
-#line 2180 "VBNET.ATG"
+#line 2178 "VBNET.ATG"
lambda.StatementBody = statement;
lambda.EndLocation = t.EndLocation;
@@ -5384,23 +5385,23 @@ out statement);
} else if (la.kind == 1) {
lexer.NextToken();
Block(
-#line 2186 "VBNET.ATG"
+#line 2184 "VBNET.ATG"
out statement);
Expect(113);
Expect(210);
-#line 2189 "VBNET.ATG"
+#line 2187 "VBNET.ATG"
lambda.StatementBody = statement;
lambda.EndLocation = t.EndLocation;
- } else SynErr(293);
+ } else SynErr(294);
}
void FunctionLambdaExpression(
-#line 2195 "VBNET.ATG"
+#line 2193 "VBNET.ATG"
out LambdaExpression lambda) {
-#line 2197 "VBNET.ATG"
+#line 2195 "VBNET.ATG"
lambda = new LambdaExpression();
TypeReference typeRef = null;
Expression inner = null;
@@ -5412,7 +5413,7 @@ out LambdaExpression lambda) {
lexer.NextToken();
if (StartOf(6)) {
FormalParameterList(
-#line 2204 "VBNET.ATG"
+#line 2202 "VBNET.ATG"
lambda.Parameters);
}
Expect(38);
@@ -5420,28 +5421,28 @@ lambda.Parameters);
if (la.kind == 63) {
lexer.NextToken();
TypeName(
-#line 2205 "VBNET.ATG"
+#line 2203 "VBNET.ATG"
out typeRef);
-#line 2205 "VBNET.ATG"
+#line 2203 "VBNET.ATG"
lambda.ReturnType = typeRef;
}
if (StartOf(41)) {
if (StartOf(29)) {
Expr(
-#line 2208 "VBNET.ATG"
+#line 2206 "VBNET.ATG"
out inner);
-#line 2210 "VBNET.ATG"
+#line 2208 "VBNET.ATG"
lambda.ExpressionBody = inner;
lambda.EndLocation = t.EndLocation; // la.Location?
} else {
EmbeddedStatement(
-#line 2214 "VBNET.ATG"
+#line 2212 "VBNET.ATG"
out statement);
-#line 2216 "VBNET.ATG"
+#line 2214 "VBNET.ATG"
lambda.StatementBody = statement;
lambda.EndLocation = t.EndLocation;
@@ -5449,23 +5450,23 @@ out statement);
} else if (la.kind == 1) {
lexer.NextToken();
Block(
-#line 2222 "VBNET.ATG"
+#line 2220 "VBNET.ATG"
out statement);
Expect(113);
Expect(127);
-#line 2225 "VBNET.ATG"
+#line 2223 "VBNET.ATG"
lambda.StatementBody = statement;
lambda.EndLocation = t.EndLocation;
- } else SynErr(294);
+ } else SynErr(295);
}
void EmbeddedStatement(
-#line 2987 "VBNET.ATG"
+#line 2985 "VBNET.ATG"
out Statement statement) {
-#line 2989 "VBNET.ATG"
+#line 2987 "VBNET.ATG"
Statement embeddedStatement = null;
statement = null;
Expression expr = null;
@@ -5475,224 +5476,224 @@ out Statement statement) {
if (la.kind == 120) {
lexer.NextToken();
-#line 2995 "VBNET.ATG"
+#line 2993 "VBNET.ATG"
ExitType exitType = ExitType.None;
switch (la.kind) {
case 210: {
lexer.NextToken();
-#line 2997 "VBNET.ATG"
+#line 2995 "VBNET.ATG"
exitType = ExitType.Sub;
break;
}
case 127: {
lexer.NextToken();
-#line 2999 "VBNET.ATG"
+#line 2997 "VBNET.ATG"
exitType = ExitType.Function;
break;
}
case 186: {
lexer.NextToken();
-#line 3001 "VBNET.ATG"
+#line 2999 "VBNET.ATG"
exitType = ExitType.Property;
break;
}
case 108: {
lexer.NextToken();
-#line 3003 "VBNET.ATG"
+#line 3001 "VBNET.ATG"
exitType = ExitType.Do;
break;
}
case 124: {
lexer.NextToken();
-#line 3005 "VBNET.ATG"
+#line 3003 "VBNET.ATG"
exitType = ExitType.For;
break;
}
case 218: {
lexer.NextToken();
-#line 3007 "VBNET.ATG"
+#line 3005 "VBNET.ATG"
exitType = ExitType.Try;
break;
}
case 231: {
lexer.NextToken();
-#line 3009 "VBNET.ATG"
+#line 3007 "VBNET.ATG"
exitType = ExitType.While;
break;
}
case 197: {
lexer.NextToken();
-#line 3011 "VBNET.ATG"
+#line 3009 "VBNET.ATG"
exitType = ExitType.Select;
break;
}
- default: SynErr(295); break;
+ default: SynErr(296); break;
}
-#line 3013 "VBNET.ATG"
+#line 3011 "VBNET.ATG"
statement = new ExitStatement(exitType);
} else if (la.kind == 218) {
TryStatement(
-#line 3014 "VBNET.ATG"
+#line 3012 "VBNET.ATG"
out statement);
} else if (la.kind == 89) {
lexer.NextToken();
-#line 3015 "VBNET.ATG"
+#line 3013 "VBNET.ATG"
ContinueType continueType = ContinueType.None;
if (la.kind == 108 || la.kind == 124 || la.kind == 231) {
if (la.kind == 108) {
lexer.NextToken();
-#line 3015 "VBNET.ATG"
+#line 3013 "VBNET.ATG"
continueType = ContinueType.Do;
} else if (la.kind == 124) {
lexer.NextToken();
-#line 3015 "VBNET.ATG"
+#line 3013 "VBNET.ATG"
continueType = ContinueType.For;
} else {
lexer.NextToken();
-#line 3015 "VBNET.ATG"
+#line 3013 "VBNET.ATG"
continueType = ContinueType.While;
}
}
-#line 3015 "VBNET.ATG"
+#line 3013 "VBNET.ATG"
statement = new ContinueStatement(continueType);
} else if (la.kind == 215) {
lexer.NextToken();
if (StartOf(29)) {
Expr(
-#line 3017 "VBNET.ATG"
+#line 3015 "VBNET.ATG"
out expr);
}
-#line 3017 "VBNET.ATG"
+#line 3015 "VBNET.ATG"
statement = new ThrowStatement(expr);
} else if (la.kind == 195) {
lexer.NextToken();
if (StartOf(29)) {
Expr(
-#line 3019 "VBNET.ATG"
+#line 3017 "VBNET.ATG"
out expr);
}
-#line 3019 "VBNET.ATG"
+#line 3017 "VBNET.ATG"
statement = new ReturnStatement(expr);
} else if (la.kind == 211) {
lexer.NextToken();
Expr(
-#line 3021 "VBNET.ATG"
+#line 3019 "VBNET.ATG"
out expr);
EndOfStmt();
Block(
-#line 3021 "VBNET.ATG"
+#line 3019 "VBNET.ATG"
out embeddedStatement);
Expect(113);
Expect(211);
-#line 3022 "VBNET.ATG"
+#line 3020 "VBNET.ATG"
statement = new LockStatement(expr, embeddedStatement);
} else if (la.kind == 189) {
lexer.NextToken();
Identifier();
-#line 3024 "VBNET.ATG"
+#line 3022 "VBNET.ATG"
name = t.val;
if (la.kind == 37) {
lexer.NextToken();
if (StartOf(42)) {
ArgumentList(
-#line 3025 "VBNET.ATG"
+#line 3023 "VBNET.ATG"
out p);
}
Expect(38);
}
-#line 3027 "VBNET.ATG"
+#line 3025 "VBNET.ATG"
statement = new RaiseEventStatement(name, p);
} else if (la.kind == 233) {
WithStatement(
-#line 3030 "VBNET.ATG"
+#line 3028 "VBNET.ATG"
out statement);
} else if (la.kind == 56) {
lexer.NextToken();
-#line 3032 "VBNET.ATG"
+#line 3030 "VBNET.ATG"
Expression handlerExpr = null;
Expr(
-#line 3033 "VBNET.ATG"
+#line 3031 "VBNET.ATG"
out expr);
Expect(22);
Expr(
-#line 3033 "VBNET.ATG"
+#line 3031 "VBNET.ATG"
out handlerExpr);
-#line 3035 "VBNET.ATG"
+#line 3033 "VBNET.ATG"
statement = new AddHandlerStatement(expr, handlerExpr);
} else if (la.kind == 193) {
lexer.NextToken();
-#line 3038 "VBNET.ATG"
+#line 3036 "VBNET.ATG"
Expression handlerExpr = null;
Expr(
-#line 3039 "VBNET.ATG"
+#line 3037 "VBNET.ATG"
out expr);
Expect(22);
Expr(
-#line 3039 "VBNET.ATG"
+#line 3037 "VBNET.ATG"
out handlerExpr);
-#line 3041 "VBNET.ATG"
+#line 3039 "VBNET.ATG"
statement = new RemoveHandlerStatement(expr, handlerExpr);
} else if (la.kind == 231) {
lexer.NextToken();
Expr(
-#line 3044 "VBNET.ATG"
+#line 3042 "VBNET.ATG"
out expr);
EndOfStmt();
Block(
-#line 3045 "VBNET.ATG"
+#line 3043 "VBNET.ATG"
out embeddedStatement);
Expect(113);
Expect(231);
-#line 3047 "VBNET.ATG"
+#line 3045 "VBNET.ATG"
statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.Start);
} else if (la.kind == 108) {
lexer.NextToken();
-#line 3052 "VBNET.ATG"
+#line 3050 "VBNET.ATG"
ConditionType conditionType = ConditionType.None;
if (la.kind == 224 || la.kind == 231) {
WhileOrUntil(
-#line 3055 "VBNET.ATG"
+#line 3053 "VBNET.ATG"
out conditionType);
Expr(
-#line 3055 "VBNET.ATG"
+#line 3053 "VBNET.ATG"
out expr);
EndOfStmt();
Block(
-#line 3056 "VBNET.ATG"
+#line 3054 "VBNET.ATG"
out embeddedStatement);
Expect(152);
-#line 3059 "VBNET.ATG"
+#line 3057 "VBNET.ATG"
statement = new DoLoopStatement(expr,
embeddedStatement,
conditionType == ConditionType.While ? ConditionType.DoWhile : conditionType,
@@ -5701,26 +5702,26 @@ out embeddedStatement);
} else if (la.kind == 1 || la.kind == 21) {
EndOfStmt();
Block(
-#line 3066 "VBNET.ATG"
+#line 3064 "VBNET.ATG"
out embeddedStatement);
Expect(152);
if (la.kind == 224 || la.kind == 231) {
WhileOrUntil(
-#line 3067 "VBNET.ATG"
+#line 3065 "VBNET.ATG"
out conditionType);
Expr(
-#line 3067 "VBNET.ATG"
+#line 3065 "VBNET.ATG"
out expr);
}
-#line 3069 "VBNET.ATG"
+#line 3067 "VBNET.ATG"
statement = new DoLoopStatement(expr, embeddedStatement, conditionType, ConditionPosition.End);
- } else SynErr(296);
+ } else SynErr(297);
} else if (la.kind == 124) {
lexer.NextToken();
-#line 3074 "VBNET.ATG"
+#line 3072 "VBNET.ATG"
Expression group = null;
TypeReference typeReference;
string typeName;
@@ -5729,24 +5730,24 @@ out expr);
if (la.kind == 110) {
lexer.NextToken();
LoopControlVariable(
-#line 3081 "VBNET.ATG"
+#line 3079 "VBNET.ATG"
out typeReference, out typeName);
Expect(138);
Expr(
-#line 3082 "VBNET.ATG"
+#line 3080 "VBNET.ATG"
out group);
EndOfStmt();
Block(
-#line 3083 "VBNET.ATG"
+#line 3081 "VBNET.ATG"
out embeddedStatement);
Expect(163);
if (StartOf(29)) {
Expr(
-#line 3084 "VBNET.ATG"
+#line 3082 "VBNET.ATG"
out expr);
}
-#line 3086 "VBNET.ATG"
+#line 3084 "VBNET.ATG"
statement = new ForeachStatement(typeReference,
typeName,
group,
@@ -5758,7 +5759,7 @@ out expr);
} else if (StartOf(43)) {
-#line 3097 "VBNET.ATG"
+#line 3095 "VBNET.ATG"
Expression start = null;
Expression end = null;
Expression step = null;
@@ -5767,59 +5768,59 @@ out expr);
List nextExpressions = null;
if (
-#line 3104 "VBNET.ATG"
+#line 3102 "VBNET.ATG"
IsLoopVariableDeclaration()) {
LoopControlVariable(
-#line 3105 "VBNET.ATG"
+#line 3103 "VBNET.ATG"
out typeReference, out typeName);
} else {
-#line 3107 "VBNET.ATG"
+#line 3105 "VBNET.ATG"
typeReference = null; typeName = null;
SimpleExpr(
-#line 3108 "VBNET.ATG"
+#line 3106 "VBNET.ATG"
out variableExpr);
}
Expect(20);
Expr(
-#line 3110 "VBNET.ATG"
+#line 3108 "VBNET.ATG"
out start);
Expect(216);
Expr(
-#line 3110 "VBNET.ATG"
+#line 3108 "VBNET.ATG"
out end);
if (la.kind == 205) {
lexer.NextToken();
Expr(
-#line 3110 "VBNET.ATG"
+#line 3108 "VBNET.ATG"
out step);
}
EndOfStmt();
Block(
-#line 3111 "VBNET.ATG"
+#line 3109 "VBNET.ATG"
out embeddedStatement);
Expect(163);
if (StartOf(29)) {
Expr(
-#line 3114 "VBNET.ATG"
+#line 3112 "VBNET.ATG"
out nextExpr);
-#line 3116 "VBNET.ATG"
+#line 3114 "VBNET.ATG"
nextExpressions = new List();
nextExpressions.Add(nextExpr);
while (la.kind == 22) {
lexer.NextToken();
Expr(
-#line 3119 "VBNET.ATG"
+#line 3117 "VBNET.ATG"
out nextExpr);
-#line 3119 "VBNET.ATG"
+#line 3117 "VBNET.ATG"
nextExpressions.Add(nextExpr);
}
}
-#line 3122 "VBNET.ATG"
+#line 3120 "VBNET.ATG"
statement = new ForNextStatement {
TypeReference = typeReference,
VariableName = typeName,
@@ -5831,31 +5832,31 @@ out nextExpr);
NextExpressions = nextExpressions
};
- } else SynErr(297);
+ } else SynErr(298);
} else if (la.kind == 118) {
lexer.NextToken();
Expr(
-#line 3135 "VBNET.ATG"
+#line 3133 "VBNET.ATG"
out expr);
-#line 3135 "VBNET.ATG"
+#line 3133 "VBNET.ATG"
statement = new ErrorStatement(expr);
} else if (la.kind == 191) {
lexer.NextToken();
-#line 3137 "VBNET.ATG"
+#line 3135 "VBNET.ATG"
bool isPreserve = false;
if (la.kind == 184) {
lexer.NextToken();
-#line 3137 "VBNET.ATG"
+#line 3135 "VBNET.ATG"
isPreserve = true;
}
ReDimClause(
-#line 3138 "VBNET.ATG"
+#line 3136 "VBNET.ATG"
out expr);
-#line 3140 "VBNET.ATG"
+#line 3138 "VBNET.ATG"
ReDimStatement reDimStatement = new ReDimStatement(isPreserve);
statement = reDimStatement;
SafeAdd(reDimStatement, reDimStatement.ReDimClauses, expr as InvocationExpression);
@@ -5863,48 +5864,48 @@ out expr);
while (la.kind == 22) {
lexer.NextToken();
ReDimClause(
-#line 3144 "VBNET.ATG"
+#line 3142 "VBNET.ATG"
out expr);
-#line 3145 "VBNET.ATG"
+#line 3143 "VBNET.ATG"
SafeAdd(reDimStatement, reDimStatement.ReDimClauses, expr as InvocationExpression);
}
} else if (la.kind == 117) {
lexer.NextToken();
Expr(
-#line 3149 "VBNET.ATG"
+#line 3147 "VBNET.ATG"
out expr);
-#line 3151 "VBNET.ATG"
+#line 3149 "VBNET.ATG"
EraseStatement eraseStatement = new EraseStatement();
if (expr != null) { SafeAdd(eraseStatement, eraseStatement.Expressions, expr);}
while (la.kind == 22) {
lexer.NextToken();
Expr(
-#line 3154 "VBNET.ATG"
+#line 3152 "VBNET.ATG"
out expr);
-#line 3154 "VBNET.ATG"
+#line 3152 "VBNET.ATG"
if (expr != null) { SafeAdd(eraseStatement, eraseStatement.Expressions, expr); }
}
-#line 3155 "VBNET.ATG"
+#line 3153 "VBNET.ATG"
statement = eraseStatement;
} else if (la.kind == 206) {
lexer.NextToken();
-#line 3157 "VBNET.ATG"
+#line 3155 "VBNET.ATG"
statement = new StopStatement();
} else if (
-#line 3159 "VBNET.ATG"
+#line 3157 "VBNET.ATG"
la.kind == Tokens.If) {
Expect(135);
-#line 3160 "VBNET.ATG"
+#line 3158 "VBNET.ATG"
Location ifStartLocation = t.Location;
Expr(
-#line 3160 "VBNET.ATG"
+#line 3158 "VBNET.ATG"
out expr);
if (la.kind == 214) {
lexer.NextToken();
@@ -5912,46 +5913,46 @@ out expr);
if (la.kind == 1 || la.kind == 21) {
EndOfStmt();
Block(
-#line 3163 "VBNET.ATG"
+#line 3161 "VBNET.ATG"
out embeddedStatement);
-#line 3165 "VBNET.ATG"
+#line 3163 "VBNET.ATG"
IfElseStatement ifStatement = new IfElseStatement(expr, embeddedStatement);
ifStatement.StartLocation = ifStartLocation;
Location elseIfStart;
while (la.kind == 112 ||
-#line 3171 "VBNET.ATG"
+#line 3169 "VBNET.ATG"
IsElseIf()) {
if (
-#line 3171 "VBNET.ATG"
+#line 3169 "VBNET.ATG"
IsElseIf()) {
Expect(111);
-#line 3171 "VBNET.ATG"
+#line 3169 "VBNET.ATG"
elseIfStart = t.Location;
Expect(135);
} else {
lexer.NextToken();
-#line 3172 "VBNET.ATG"
+#line 3170 "VBNET.ATG"
elseIfStart = t.Location;
}
-#line 3174 "VBNET.ATG"
+#line 3172 "VBNET.ATG"
Expression condition = null; Statement block = null;
Expr(
-#line 3175 "VBNET.ATG"
+#line 3173 "VBNET.ATG"
out condition);
if (la.kind == 214) {
lexer.NextToken();
}
EndOfStmt();
Block(
-#line 3176 "VBNET.ATG"
+#line 3174 "VBNET.ATG"
out block);
-#line 3178 "VBNET.ATG"
+#line 3176 "VBNET.ATG"
ElseIfSection elseIfSection = new ElseIfSection(condition, block);
elseIfSection.StartLocation = elseIfStart;
elseIfSection.EndLocation = t.Location;
@@ -5965,123 +5966,123 @@ out block);
EndOfStmt();
}
Block(
-#line 3187 "VBNET.ATG"
+#line 3185 "VBNET.ATG"
out embeddedStatement);
-#line 3189 "VBNET.ATG"
+#line 3187 "VBNET.ATG"
ifStatement.FalseStatement.Add(embeddedStatement);
}
Expect(113);
Expect(135);
-#line 3193 "VBNET.ATG"
+#line 3191 "VBNET.ATG"
ifStatement.EndLocation = t.Location;
statement = ifStatement;
} else if (StartOf(44)) {
-#line 3198 "VBNET.ATG"
+#line 3196 "VBNET.ATG"
IfElseStatement ifStatement = new IfElseStatement(expr);
ifStatement.StartLocation = ifStartLocation;
SingleLineStatementList(
-#line 3201 "VBNET.ATG"
+#line 3199 "VBNET.ATG"
ifStatement.TrueStatement);
if (la.kind == 111) {
lexer.NextToken();
if (StartOf(44)) {
SingleLineStatementList(
-#line 3204 "VBNET.ATG"
+#line 3202 "VBNET.ATG"
ifStatement.FalseStatement);
}
}
-#line 3206 "VBNET.ATG"
+#line 3204 "VBNET.ATG"
ifStatement.EndLocation = t.Location; statement = ifStatement;
- } else SynErr(298);
+ } else SynErr(299);
} else if (la.kind == 197) {
lexer.NextToken();
if (la.kind == 74) {
lexer.NextToken();
}
Expr(
-#line 3209 "VBNET.ATG"
+#line 3207 "VBNET.ATG"
out expr);
EndOfStmt();
-#line 3210 "VBNET.ATG"
+#line 3208 "VBNET.ATG"
List selectSections = new List();
Statement block = null;
while (la.kind == 74) {
-#line 3214 "VBNET.ATG"
+#line 3212 "VBNET.ATG"
List caseClauses = null; Location caseLocation = la.Location;
lexer.NextToken();
CaseClauses(
-#line 3215 "VBNET.ATG"
+#line 3213 "VBNET.ATG"
out caseClauses);
if (
-#line 3215 "VBNET.ATG"
+#line 3213 "VBNET.ATG"
IsNotStatementSeparator()) {
lexer.NextToken();
}
EndOfStmt();
-#line 3217 "VBNET.ATG"
+#line 3215 "VBNET.ATG"
SwitchSection selectSection = new SwitchSection(caseClauses);
selectSection.StartLocation = caseLocation;
Block(
-#line 3220 "VBNET.ATG"
+#line 3218 "VBNET.ATG"
out block);
-#line 3222 "VBNET.ATG"
+#line 3220 "VBNET.ATG"
selectSection.Children = block.Children;
selectSection.EndLocation = t.EndLocation;
selectSections.Add(selectSection);
}
-#line 3228 "VBNET.ATG"
+#line 3226 "VBNET.ATG"
statement = new SwitchStatement(expr, selectSections);
Expect(113);
Expect(197);
} else if (la.kind == 171) {
-#line 3231 "VBNET.ATG"
+#line 3229 "VBNET.ATG"
OnErrorStatement onErrorStatement = null;
OnErrorStatement(
-#line 3232 "VBNET.ATG"
+#line 3230 "VBNET.ATG"
out onErrorStatement);
-#line 3232 "VBNET.ATG"
+#line 3230 "VBNET.ATG"
statement = onErrorStatement;
} else if (la.kind == 132) {
-#line 3233 "VBNET.ATG"
+#line 3231 "VBNET.ATG"
GotoStatement goToStatement = null;
GotoStatement(
-#line 3234 "VBNET.ATG"
+#line 3232 "VBNET.ATG"
out goToStatement);
-#line 3234 "VBNET.ATG"
+#line 3232 "VBNET.ATG"
statement = goToStatement;
} else if (la.kind == 194) {
-#line 3235 "VBNET.ATG"
+#line 3233 "VBNET.ATG"
ResumeStatement resumeStatement = null;
ResumeStatement(
-#line 3236 "VBNET.ATG"
+#line 3234 "VBNET.ATG"
out resumeStatement);
-#line 3236 "VBNET.ATG"
+#line 3234 "VBNET.ATG"
statement = resumeStatement;
} else if (StartOf(43)) {
-#line 3239 "VBNET.ATG"
+#line 3237 "VBNET.ATG"
Expression val = null;
AssignmentOperatorType op;
@@ -6089,25 +6090,25 @@ out resumeStatement);
la.kind == Tokens.Not || la.kind == Tokens.Times;
SimpleExpr(
-#line 3245 "VBNET.ATG"
+#line 3243 "VBNET.ATG"
out expr);
if (StartOf(45)) {
AssignmentOperator(
-#line 3247 "VBNET.ATG"
+#line 3245 "VBNET.ATG"
out op);
Expr(
-#line 3247 "VBNET.ATG"
+#line 3245 "VBNET.ATG"
out val);
-#line 3247 "VBNET.ATG"
+#line 3245 "VBNET.ATG"
expr = new AssignmentExpression(expr, op, val);
} else if (StartOf(46)) {
-#line 3248 "VBNET.ATG"
+#line 3246 "VBNET.ATG"
if (mustBeAssignment) Error("error in assignment.");
- } else SynErr(299);
+ } else SynErr(300);
-#line 3251 "VBNET.ATG"
+#line 3249 "VBNET.ATG"
// a field reference expression that stands alone is a
// invocation expression without parantheses and arguments
if(expr is MemberReferenceExpression || expr is IdentifierExpression) {
@@ -6118,88 +6119,88 @@ out val);
} else if (la.kind == 73) {
lexer.NextToken();
SimpleExpr(
-#line 3258 "VBNET.ATG"
+#line 3256 "VBNET.ATG"
out expr);
-#line 3258 "VBNET.ATG"
+#line 3256 "VBNET.ATG"
statement = new ExpressionStatement(expr);
} else if (la.kind == 226) {
lexer.NextToken();
-#line 3260 "VBNET.ATG"
+#line 3258 "VBNET.ATG"
Statement block;
if (
-#line 3261 "VBNET.ATG"
+#line 3259 "VBNET.ATG"
Peek(1).kind == Tokens.As) {
-#line 3262 "VBNET.ATG"
+#line 3260 "VBNET.ATG"
LocalVariableDeclaration resourceAquisition = new LocalVariableDeclaration(Modifiers.None);
VariableDeclarator(
-#line 3263 "VBNET.ATG"
+#line 3261 "VBNET.ATG"
resourceAquisition.Variables);
while (la.kind == 22) {
lexer.NextToken();
VariableDeclarator(
-#line 3265 "VBNET.ATG"
+#line 3263 "VBNET.ATG"
resourceAquisition.Variables);
}
Block(
-#line 3267 "VBNET.ATG"
+#line 3265 "VBNET.ATG"
out block);
-#line 3269 "VBNET.ATG"
+#line 3267 "VBNET.ATG"
statement = new UsingStatement(resourceAquisition, block);
} else if (StartOf(29)) {
Expr(
-#line 3271 "VBNET.ATG"
+#line 3269 "VBNET.ATG"
out expr);
Block(
-#line 3272 "VBNET.ATG"
+#line 3270 "VBNET.ATG"
out block);
-#line 3273 "VBNET.ATG"
+#line 3271 "VBNET.ATG"
statement = new UsingStatement(new ExpressionStatement(expr), block);
- } else SynErr(300);
+ } else SynErr(301);
Expect(113);
Expect(226);
} else if (StartOf(47)) {
LocalDeclarationStatement(
-#line 3276 "VBNET.ATG"
+#line 3274 "VBNET.ATG"
out statement);
- } else SynErr(301);
+ } else SynErr(302);
}
void FromOrAggregateQueryOperator(
-#line 2244 "VBNET.ATG"
+#line 2242 "VBNET.ATG"
List middleClauses) {
-#line 2246 "VBNET.ATG"
+#line 2244 "VBNET.ATG"
QueryExpressionFromClause fromClause = null;
QueryExpressionAggregateClause aggregateClause = null;
if (la.kind == 126) {
FromQueryOperator(
-#line 2249 "VBNET.ATG"
+#line 2247 "VBNET.ATG"
out fromClause);
-#line 2250 "VBNET.ATG"
+#line 2248 "VBNET.ATG"
middleClauses.Add(fromClause);
} else if (la.kind == 58) {
AggregateQueryOperator(
-#line 2251 "VBNET.ATG"
+#line 2249 "VBNET.ATG"
out aggregateClause);
-#line 2252 "VBNET.ATG"
+#line 2250 "VBNET.ATG"
middleClauses.Add(aggregateClause);
- } else SynErr(302);
+ } else SynErr(303);
}
void QueryOperator(
-#line 2255 "VBNET.ATG"
+#line 2253 "VBNET.ATG"
List middleClauses) {
-#line 2257 "VBNET.ATG"
+#line 2255 "VBNET.ATG"
QueryExpressionJoinVBClause joinClause = null;
QueryExpressionGroupVBClause groupByClause = null;
QueryExpressionPartitionVBClause partitionClause = null;
@@ -6209,94 +6210,94 @@ List middleClauses) {
if (la.kind == 126) {
FromQueryOperator(
-#line 2264 "VBNET.ATG"
+#line 2262 "VBNET.ATG"
out fromClause);
-#line 2265 "VBNET.ATG"
+#line 2263 "VBNET.ATG"
middleClauses.Add(fromClause);
} else if (la.kind == 58) {
AggregateQueryOperator(
-#line 2266 "VBNET.ATG"
+#line 2264 "VBNET.ATG"
out aggregateClause);
-#line 2267 "VBNET.ATG"
+#line 2265 "VBNET.ATG"
middleClauses.Add(aggregateClause);
} else if (la.kind == 197) {
SelectQueryOperator(
-#line 2268 "VBNET.ATG"
+#line 2266 "VBNET.ATG"
middleClauses);
} else if (la.kind == 107) {
DistinctQueryOperator(
-#line 2269 "VBNET.ATG"
+#line 2267 "VBNET.ATG"
middleClauses);
} else if (la.kind == 230) {
WhereQueryOperator(
-#line 2270 "VBNET.ATG"
+#line 2268 "VBNET.ATG"
middleClauses);
} else if (la.kind == 176) {
OrderByQueryOperator(
-#line 2271 "VBNET.ATG"
+#line 2269 "VBNET.ATG"
middleClauses);
} else if (la.kind == 203 || la.kind == 212) {
PartitionQueryOperator(
-#line 2272 "VBNET.ATG"
+#line 2270 "VBNET.ATG"
out partitionClause);
-#line 2273 "VBNET.ATG"
+#line 2271 "VBNET.ATG"
middleClauses.Add(partitionClause);
} else if (la.kind == 148) {
LetQueryOperator(
-#line 2274 "VBNET.ATG"
+#line 2272 "VBNET.ATG"
middleClauses);
} else if (la.kind == 146) {
JoinQueryOperator(
-#line 2275 "VBNET.ATG"
+#line 2273 "VBNET.ATG"
out joinClause);
-#line 2276 "VBNET.ATG"
+#line 2274 "VBNET.ATG"
middleClauses.Add(joinClause);
} else if (
-#line 2277 "VBNET.ATG"
+#line 2275 "VBNET.ATG"
la.kind == Tokens.Group && Peek(1).kind == Tokens.Join) {
GroupJoinQueryOperator(
-#line 2277 "VBNET.ATG"
+#line 2275 "VBNET.ATG"
out groupJoinClause);
-#line 2278 "VBNET.ATG"
+#line 2276 "VBNET.ATG"
middleClauses.Add(groupJoinClause);
} else if (la.kind == 133) {
GroupByQueryOperator(
-#line 2279 "VBNET.ATG"
+#line 2277 "VBNET.ATG"
out groupByClause);
-#line 2280 "VBNET.ATG"
+#line 2278 "VBNET.ATG"
middleClauses.Add(groupByClause);
- } else SynErr(303);
+ } else SynErr(304);
}
void FromQueryOperator(
-#line 2355 "VBNET.ATG"
+#line 2353 "VBNET.ATG"
out QueryExpressionFromClause fromClause) {
-#line 2357 "VBNET.ATG"
+#line 2355 "VBNET.ATG"
fromClause = new QueryExpressionFromClause();
fromClause.StartLocation = la.Location;
Expect(126);
CollectionRangeVariableDeclarationList(
-#line 2360 "VBNET.ATG"
+#line 2358 "VBNET.ATG"
fromClause.Sources);
-#line 2362 "VBNET.ATG"
+#line 2360 "VBNET.ATG"
fromClause.EndLocation = t.EndLocation;
}
void AggregateQueryOperator(
-#line 2424 "VBNET.ATG"
+#line 2422 "VBNET.ATG"
out QueryExpressionAggregateClause aggregateClause) {
-#line 2426 "VBNET.ATG"
+#line 2424 "VBNET.ATG"
aggregateClause = new QueryExpressionAggregateClause();
aggregateClause.IntoVariables = new List();
aggregateClause.StartLocation = la.Location;
@@ -6304,77 +6305,77 @@ out QueryExpressionAggregateClause aggregateClause) {
Expect(58);
CollectionRangeVariableDeclaration(
-#line 2431 "VBNET.ATG"
+#line 2429 "VBNET.ATG"
out source);
-#line 2433 "VBNET.ATG"
+#line 2431 "VBNET.ATG"
aggregateClause.Source = source;
while (StartOf(30)) {
QueryOperator(
-#line 2436 "VBNET.ATG"
+#line 2434 "VBNET.ATG"
aggregateClause.MiddleClauses);
}
Expect(143);
ExpressionRangeVariableDeclarationList(
-#line 2438 "VBNET.ATG"
+#line 2436 "VBNET.ATG"
aggregateClause.IntoVariables);
-#line 2440 "VBNET.ATG"
+#line 2438 "VBNET.ATG"
aggregateClause.EndLocation = t.EndLocation;
}
void SelectQueryOperator(
-#line 2366 "VBNET.ATG"
+#line 2364 "VBNET.ATG"
List middleClauses) {
-#line 2368 "VBNET.ATG"
+#line 2366 "VBNET.ATG"
QueryExpressionSelectVBClause selectClause = new QueryExpressionSelectVBClause();
selectClause.StartLocation = la.Location;
Expect(197);
ExpressionRangeVariableDeclarationList(
-#line 2371 "VBNET.ATG"
+#line 2369 "VBNET.ATG"
selectClause.Variables);
-#line 2373 "VBNET.ATG"
+#line 2371 "VBNET.ATG"
selectClause.EndLocation = t.Location;
middleClauses.Add(selectClause);
}
void DistinctQueryOperator(
-#line 2378 "VBNET.ATG"
+#line 2376 "VBNET.ATG"
List middleClauses) {
-#line 2380 "VBNET.ATG"
+#line 2378 "VBNET.ATG"
QueryExpressionDistinctClause distinctClause = new QueryExpressionDistinctClause();
distinctClause.StartLocation = la.Location;
Expect(107);
-#line 2385 "VBNET.ATG"
+#line 2383 "VBNET.ATG"
distinctClause.EndLocation = t.EndLocation;
middleClauses.Add(distinctClause);
}
void WhereQueryOperator(
-#line 2390 "VBNET.ATG"
+#line 2388 "VBNET.ATG"
List middleClauses) {
-#line 2392 "VBNET.ATG"
+#line 2390 "VBNET.ATG"
QueryExpressionWhereClause whereClause = new QueryExpressionWhereClause();
whereClause.StartLocation = la.Location;
Expression operand = null;
Expect(230);
Expr(
-#line 2396 "VBNET.ATG"
+#line 2394 "VBNET.ATG"
out operand);
-#line 2398 "VBNET.ATG"
+#line 2396 "VBNET.ATG"
whereClause.Condition = operand;
whereClause.EndLocation = t.EndLocation;
@@ -6383,10 +6384,10 @@ out operand);
}
void OrderByQueryOperator(
-#line 2283 "VBNET.ATG"
+#line 2281 "VBNET.ATG"
List middleClauses) {
-#line 2285 "VBNET.ATG"
+#line 2283 "VBNET.ATG"
QueryExpressionOrderClause orderClause = new QueryExpressionOrderClause();
orderClause.StartLocation = la.Location;
List orderings = null;
@@ -6394,10 +6395,10 @@ List middleClauses) {
Expect(176);
Expect(70);
OrderExpressionList(
-#line 2289 "VBNET.ATG"
+#line 2287 "VBNET.ATG"
out orderings);
-#line 2291 "VBNET.ATG"
+#line 2289 "VBNET.ATG"
orderClause.Orderings = orderings;
orderClause.EndLocation = t.EndLocation;
middleClauses.Add(orderClause);
@@ -6405,10 +6406,10 @@ out orderings);
}
void PartitionQueryOperator(
-#line 2405 "VBNET.ATG"
+#line 2403 "VBNET.ATG"
out QueryExpressionPartitionVBClause partitionClause) {
-#line 2407 "VBNET.ATG"
+#line 2405 "VBNET.ATG"
partitionClause = new QueryExpressionPartitionVBClause();
partitionClause.StartLocation = la.Location;
Expression expr = null;
@@ -6416,60 +6417,60 @@ out QueryExpressionPartitionVBClause partitionClause) {
if (la.kind == 212) {
lexer.NextToken();
-#line 2412 "VBNET.ATG"
+#line 2410 "VBNET.ATG"
partitionClause.PartitionType = QueryExpressionPartitionType.Take;
if (la.kind == 231) {
lexer.NextToken();
-#line 2413 "VBNET.ATG"
+#line 2411 "VBNET.ATG"
partitionClause.PartitionType = QueryExpressionPartitionType.TakeWhile;
}
} else if (la.kind == 203) {
lexer.NextToken();
-#line 2414 "VBNET.ATG"
+#line 2412 "VBNET.ATG"
partitionClause.PartitionType = QueryExpressionPartitionType.Skip;
if (la.kind == 231) {
lexer.NextToken();
-#line 2415 "VBNET.ATG"
+#line 2413 "VBNET.ATG"
partitionClause.PartitionType = QueryExpressionPartitionType.SkipWhile;
}
- } else SynErr(304);
+ } else SynErr(305);
Expr(
-#line 2417 "VBNET.ATG"
+#line 2415 "VBNET.ATG"
out expr);
-#line 2419 "VBNET.ATG"
+#line 2417 "VBNET.ATG"
partitionClause.Expression = expr;
partitionClause.EndLocation = t.EndLocation;
}
void LetQueryOperator(
-#line 2444 "VBNET.ATG"
+#line 2442 "VBNET.ATG"
List middleClauses) {
-#line 2446 "VBNET.ATG"
+#line 2444 "VBNET.ATG"
QueryExpressionLetVBClause letClause = new QueryExpressionLetVBClause();
letClause.StartLocation = la.Location;
Expect(148);
ExpressionRangeVariableDeclarationList(
-#line 2449 "VBNET.ATG"
+#line 2447 "VBNET.ATG"
letClause.Variables);
-#line 2451 "VBNET.ATG"
+#line 2449 "VBNET.ATG"
letClause.EndLocation = t.EndLocation;
middleClauses.Add(letClause);
}
void JoinQueryOperator(
-#line 2488 "VBNET.ATG"
+#line 2486 "VBNET.ATG"
out QueryExpressionJoinVBClause joinClause) {
-#line 2490 "VBNET.ATG"
+#line 2488 "VBNET.ATG"
joinClause = new QueryExpressionJoinVBClause();
joinClause.StartLocation = la.Location;
CollectionRangeVariable joinVariable = null;
@@ -6479,203 +6480,203 @@ out QueryExpressionJoinVBClause joinClause) {
Expect(146);
CollectionRangeVariableDeclaration(
-#line 2497 "VBNET.ATG"
+#line 2495 "VBNET.ATG"
out joinVariable);
-#line 2498 "VBNET.ATG"
+#line 2496 "VBNET.ATG"
joinClause.JoinVariable = joinVariable;
if (la.kind == 146) {
JoinQueryOperator(
-#line 2500 "VBNET.ATG"
+#line 2498 "VBNET.ATG"
out subJoin);
-#line 2501 "VBNET.ATG"
+#line 2499 "VBNET.ATG"
joinClause.SubJoin = subJoin;
}
Expect(171);
JoinCondition(
-#line 2504 "VBNET.ATG"
+#line 2502 "VBNET.ATG"
out condition);
-#line 2505 "VBNET.ATG"
+#line 2503 "VBNET.ATG"
SafeAdd(joinClause, joinClause.Conditions, condition);
while (la.kind == 60) {
lexer.NextToken();
JoinCondition(
-#line 2507 "VBNET.ATG"
+#line 2505 "VBNET.ATG"
out condition);
-#line 2508 "VBNET.ATG"
+#line 2506 "VBNET.ATG"
SafeAdd(joinClause, joinClause.Conditions, condition);
}
-#line 2511 "VBNET.ATG"
+#line 2509 "VBNET.ATG"
joinClause.EndLocation = t.EndLocation;
}
void GroupJoinQueryOperator(
-#line 2341 "VBNET.ATG"
+#line 2339 "VBNET.ATG"
out QueryExpressionGroupJoinVBClause groupJoinClause) {
-#line 2343 "VBNET.ATG"
+#line 2341 "VBNET.ATG"
groupJoinClause = new QueryExpressionGroupJoinVBClause();
groupJoinClause.StartLocation = la.Location;
QueryExpressionJoinVBClause joinClause = null;
Expect(133);
JoinQueryOperator(
-#line 2347 "VBNET.ATG"
+#line 2345 "VBNET.ATG"
out joinClause);
Expect(143);
ExpressionRangeVariableDeclarationList(
-#line 2348 "VBNET.ATG"
+#line 2346 "VBNET.ATG"
groupJoinClause.IntoVariables);
-#line 2350 "VBNET.ATG"
+#line 2348 "VBNET.ATG"
groupJoinClause.JoinClause = joinClause;
groupJoinClause.EndLocation = t.EndLocation;
}
void GroupByQueryOperator(
-#line 2328 "VBNET.ATG"
+#line 2326 "VBNET.ATG"
out QueryExpressionGroupVBClause groupByClause) {
-#line 2330 "VBNET.ATG"
+#line 2328 "VBNET.ATG"
groupByClause = new QueryExpressionGroupVBClause();
groupByClause.StartLocation = la.Location;
Expect(133);
ExpressionRangeVariableDeclarationList(
-#line 2333 "VBNET.ATG"
+#line 2331 "VBNET.ATG"
groupByClause.GroupVariables);
Expect(70);
ExpressionRangeVariableDeclarationList(
-#line 2334 "VBNET.ATG"
+#line 2332 "VBNET.ATG"
groupByClause.ByVariables);
Expect(143);
ExpressionRangeVariableDeclarationList(
-#line 2335 "VBNET.ATG"
+#line 2333 "VBNET.ATG"
groupByClause.IntoVariables);
-#line 2337 "VBNET.ATG"
+#line 2335 "VBNET.ATG"
groupByClause.EndLocation = t.EndLocation;
}
void OrderExpressionList(
-#line 2297 "VBNET.ATG"
+#line 2295 "VBNET.ATG"
out List orderings) {
-#line 2299 "VBNET.ATG"
+#line 2297 "VBNET.ATG"
orderings = new List();
QueryExpressionOrdering ordering = null;
OrderExpression(
-#line 2302 "VBNET.ATG"
+#line 2300 "VBNET.ATG"
out ordering);
-#line 2303 "VBNET.ATG"
+#line 2301 "VBNET.ATG"
orderings.Add(ordering);
while (la.kind == 22) {
lexer.NextToken();
OrderExpression(
-#line 2305 "VBNET.ATG"
+#line 2303 "VBNET.ATG"
out ordering);
-#line 2306 "VBNET.ATG"
+#line 2304 "VBNET.ATG"
orderings.Add(ordering);
}
}
void OrderExpression(
-#line 2310 "VBNET.ATG"
+#line 2308 "VBNET.ATG"
out QueryExpressionOrdering ordering) {
-#line 2312 "VBNET.ATG"
+#line 2310 "VBNET.ATG"
ordering = new QueryExpressionOrdering();
ordering.StartLocation = la.Location;
ordering.Direction = QueryExpressionOrderingDirection.None;
Expression orderExpr = null;
Expr(
-#line 2317 "VBNET.ATG"
+#line 2315 "VBNET.ATG"
out orderExpr);
-#line 2319 "VBNET.ATG"
+#line 2317 "VBNET.ATG"
ordering.Criteria = orderExpr;
if (la.kind == 64 || la.kind == 104) {
if (la.kind == 64) {
lexer.NextToken();
-#line 2322 "VBNET.ATG"
+#line 2320 "VBNET.ATG"
ordering.Direction = QueryExpressionOrderingDirection.Ascending;
} else {
lexer.NextToken();
-#line 2323 "VBNET.ATG"
+#line 2321 "VBNET.ATG"
ordering.Direction = QueryExpressionOrderingDirection.Descending;
}
}
-#line 2325 "VBNET.ATG"
+#line 2323 "VBNET.ATG"
ordering.EndLocation = t.EndLocation;
}
void ExpressionRangeVariableDeclarationList(
-#line 2456 "VBNET.ATG"
+#line 2454 "VBNET.ATG"
List variables) {
-#line 2458 "VBNET.ATG"
+#line 2456 "VBNET.ATG"
ExpressionRangeVariable variable = null;
ExpressionRangeVariableDeclaration(
-#line 2460 "VBNET.ATG"
+#line 2458 "VBNET.ATG"
out variable);
-#line 2461 "VBNET.ATG"
+#line 2459 "VBNET.ATG"
variables.Add(variable);
while (la.kind == 22) {
lexer.NextToken();
ExpressionRangeVariableDeclaration(
-#line 2462 "VBNET.ATG"
+#line 2460 "VBNET.ATG"
out variable);
-#line 2462 "VBNET.ATG"
+#line 2460 "VBNET.ATG"
variables.Add(variable);
}
}
void CollectionRangeVariableDeclarationList(
-#line 2515 "VBNET.ATG"
+#line 2513 "VBNET.ATG"
List rangeVariables) {
-#line 2516 "VBNET.ATG"
+#line 2514 "VBNET.ATG"
CollectionRangeVariable variableDeclaration;
CollectionRangeVariableDeclaration(
-#line 2518 "VBNET.ATG"
+#line 2516 "VBNET.ATG"
out variableDeclaration);
-#line 2519 "VBNET.ATG"
+#line 2517 "VBNET.ATG"
rangeVariables.Add(variableDeclaration);
while (la.kind == 22) {
lexer.NextToken();
CollectionRangeVariableDeclaration(
-#line 2520 "VBNET.ATG"
+#line 2518 "VBNET.ATG"
out variableDeclaration);
-#line 2520 "VBNET.ATG"
+#line 2518 "VBNET.ATG"
rangeVariables.Add(variableDeclaration);
}
}
void CollectionRangeVariableDeclaration(
-#line 2523 "VBNET.ATG"
+#line 2521 "VBNET.ATG"
out CollectionRangeVariable rangeVariable) {
-#line 2525 "VBNET.ATG"
+#line 2523 "VBNET.ATG"
rangeVariable = new CollectionRangeVariable();
rangeVariable.StartLocation = la.Location;
TypeReference typeName = null;
@@ -6683,71 +6684,71 @@ out CollectionRangeVariable rangeVariable) {
Identifier();
-#line 2530 "VBNET.ATG"
+#line 2528 "VBNET.ATG"
rangeVariable.Identifier = t.val;
if (la.kind == 63) {
lexer.NextToken();
TypeName(
-#line 2531 "VBNET.ATG"
+#line 2529 "VBNET.ATG"
out typeName);
-#line 2531 "VBNET.ATG"
+#line 2529 "VBNET.ATG"
rangeVariable.Type = typeName;
}
Expect(138);
Expr(
-#line 2532 "VBNET.ATG"
+#line 2530 "VBNET.ATG"
out inExpr);
-#line 2534 "VBNET.ATG"
+#line 2532 "VBNET.ATG"
rangeVariable.Expression = inExpr;
rangeVariable.EndLocation = t.EndLocation;
}
void ExpressionRangeVariableDeclaration(
-#line 2465 "VBNET.ATG"
+#line 2463 "VBNET.ATG"
out ExpressionRangeVariable variable) {
-#line 2467 "VBNET.ATG"
+#line 2465 "VBNET.ATG"
variable = new ExpressionRangeVariable();
variable.StartLocation = la.Location;
Expression rhs = null;
TypeReference typeName = null;
if (
-#line 2473 "VBNET.ATG"
+#line 2471 "VBNET.ATG"
IsIdentifiedExpressionRange()) {
Identifier();
-#line 2474 "VBNET.ATG"
+#line 2472 "VBNET.ATG"
variable.Identifier = t.val;
if (la.kind == 63) {
lexer.NextToken();
TypeName(
-#line 2476 "VBNET.ATG"
+#line 2474 "VBNET.ATG"
out typeName);
-#line 2477 "VBNET.ATG"
+#line 2475 "VBNET.ATG"
variable.Type = typeName;
}
Expect(20);
}
Expr(
-#line 2481 "VBNET.ATG"
+#line 2479 "VBNET.ATG"
out rhs);
-#line 2483 "VBNET.ATG"
+#line 2481 "VBNET.ATG"
variable.Expression = rhs;
variable.EndLocation = t.EndLocation;
}
void JoinCondition(
-#line 2539 "VBNET.ATG"
+#line 2537 "VBNET.ATG"
out QueryExpressionJoinConditionVB condition) {
-#line 2541 "VBNET.ATG"
+#line 2539 "VBNET.ATG"
condition = new QueryExpressionJoinConditionVB();
condition.StartLocation = la.Location;
@@ -6755,14 +6756,14 @@ out QueryExpressionJoinConditionVB condition) {
Expression rhs = null;
Expr(
-#line 2547 "VBNET.ATG"
+#line 2545 "VBNET.ATG"
out lhs);
Expect(116);
Expr(
-#line 2547 "VBNET.ATG"
+#line 2545 "VBNET.ATG"
out rhs);
-#line 2549 "VBNET.ATG"
+#line 2547 "VBNET.ATG"
condition.LeftSide = lhs;
condition.RightSide = rhs;
condition.EndLocation = t.EndLocation;
@@ -6770,93 +6771,93 @@ out rhs);
}
void Argument(
-#line 2613 "VBNET.ATG"
+#line 2611 "VBNET.ATG"
out Expression argumentexpr) {
-#line 2615 "VBNET.ATG"
+#line 2613 "VBNET.ATG"
Expression expr;
argumentexpr = null;
string name;
if (
-#line 2619 "VBNET.ATG"
+#line 2617 "VBNET.ATG"
IsNamedAssign()) {
Identifier();
-#line 2619 "VBNET.ATG"
+#line 2617 "VBNET.ATG"
name = t.val;
Expect(55);
Expr(
-#line 2619 "VBNET.ATG"
+#line 2617 "VBNET.ATG"
out expr);
-#line 2621 "VBNET.ATG"
+#line 2619 "VBNET.ATG"
argumentexpr = new NamedArgumentExpression(name, expr);
} else if (StartOf(29)) {
Expr(
-#line 2624 "VBNET.ATG"
+#line 2622 "VBNET.ATG"
out argumentexpr);
- } else SynErr(305);
+ } else SynErr(306);
}
void QualIdentAndTypeArguments(
-#line 2690 "VBNET.ATG"
+#line 2688 "VBNET.ATG"
out TypeReference typeref, bool canBeUnbound) {
-#line 2691 "VBNET.ATG"
+#line 2689 "VBNET.ATG"
string name; typeref = null;
Qualident(
-#line 2693 "VBNET.ATG"
+#line 2691 "VBNET.ATG"
out name);
-#line 2694 "VBNET.ATG"
+#line 2692 "VBNET.ATG"
typeref = new TypeReference(name);
if (
-#line 2695 "VBNET.ATG"
+#line 2693 "VBNET.ATG"
la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
lexer.NextToken();
Expect(169);
if (
-#line 2697 "VBNET.ATG"
+#line 2695 "VBNET.ATG"
canBeUnbound && (la.kind == Tokens.CloseParenthesis || la.kind == Tokens.Comma)) {
-#line 2698 "VBNET.ATG"
+#line 2696 "VBNET.ATG"
typeref.GenericTypes.Add(NullTypeReference.Instance);
while (la.kind == 22) {
lexer.NextToken();
-#line 2699 "VBNET.ATG"
+#line 2697 "VBNET.ATG"
typeref.GenericTypes.Add(NullTypeReference.Instance);
}
} else if (StartOf(8)) {
TypeArgumentList(
-#line 2700 "VBNET.ATG"
+#line 2698 "VBNET.ATG"
typeref.GenericTypes);
- } else SynErr(306);
+ } else SynErr(307);
Expect(38);
}
}
void RankList(
-#line 2737 "VBNET.ATG"
+#line 2735 "VBNET.ATG"
out int i) {
-#line 2738 "VBNET.ATG"
+#line 2736 "VBNET.ATG"
i = 0;
while (la.kind == 22) {
lexer.NextToken();
-#line 2739 "VBNET.ATG"
+#line 2737 "VBNET.ATG"
++i;
}
}
void Attribute(
-#line 2778 "VBNET.ATG"
+#line 2776 "VBNET.ATG"
out ASTAttribute attribute) {
-#line 2779 "VBNET.ATG"
+#line 2777 "VBNET.ATG"
string name;
List positional = new List();
List named = new List();
@@ -6866,52 +6867,52 @@ out ASTAttribute attribute) {
Expect(26);
}
Qualident(
-#line 2784 "VBNET.ATG"
+#line 2782 "VBNET.ATG"
out name);
if (la.kind == 37) {
AttributeArguments(
-#line 2785 "VBNET.ATG"
+#line 2783 "VBNET.ATG"
positional, named);
}
-#line 2787 "VBNET.ATG"
+#line 2785 "VBNET.ATG"
attribute = new ASTAttribute(name, positional, named);
}
void AttributeArguments(
-#line 2792 "VBNET.ATG"
+#line 2790 "VBNET.ATG"
List positional, List named) {
-#line 2794 "VBNET.ATG"
+#line 2792 "VBNET.ATG"
bool nameFound = false;
string name = "";
Expression expr;
Expect(37);
if (
-#line 2800 "VBNET.ATG"
+#line 2798 "VBNET.ATG"
IsNotClosingParenthesis()) {
if (
-#line 2802 "VBNET.ATG"
+#line 2800 "VBNET.ATG"
IsNamedAssign()) {
-#line 2802 "VBNET.ATG"
+#line 2800 "VBNET.ATG"
nameFound = true;
IdentifierOrKeyword(
-#line 2803 "VBNET.ATG"
+#line 2801 "VBNET.ATG"
out name);
if (la.kind == 55) {
lexer.NextToken();
} else if (la.kind == 20) {
lexer.NextToken();
- } else SynErr(307);
+ } else SynErr(308);
}
Expr(
-#line 2805 "VBNET.ATG"
+#line 2803 "VBNET.ATG"
out expr);
-#line 2807 "VBNET.ATG"
+#line 2805 "VBNET.ATG"
if (expr != null) {
if (string.IsNullOrEmpty(name)) { positional.Add(expr); }
else { named.Add(new NamedArgumentExpression(name, expr)); name = ""; }
@@ -6920,29 +6921,29 @@ out expr);
while (la.kind == 22) {
lexer.NextToken();
if (
-#line 2815 "VBNET.ATG"
+#line 2813 "VBNET.ATG"
IsNamedAssign()) {
-#line 2815 "VBNET.ATG"
+#line 2813 "VBNET.ATG"
nameFound = true;
IdentifierOrKeyword(
-#line 2816 "VBNET.ATG"
+#line 2814 "VBNET.ATG"
out name);
if (la.kind == 55) {
lexer.NextToken();
} else if (la.kind == 20) {
lexer.NextToken();
- } else SynErr(308);
+ } else SynErr(309);
} else if (StartOf(29)) {
-#line 2818 "VBNET.ATG"
+#line 2816 "VBNET.ATG"
if (nameFound) Error("no positional argument after named argument");
- } else SynErr(309);
+ } else SynErr(310);
Expr(
-#line 2819 "VBNET.ATG"
+#line 2817 "VBNET.ATG"
out expr);
-#line 2819 "VBNET.ATG"
+#line 2817 "VBNET.ATG"
if (expr != null) { if(name == "") positional.Add(expr);
else { named.Add(new NamedArgumentExpression(name, expr)); name = ""; }
}
@@ -6953,10 +6954,10 @@ out expr);
}
void FormalParameter(
-#line 2876 "VBNET.ATG"
+#line 2874 "VBNET.ATG"
out ParameterDeclarationExpression p) {
-#line 2878 "VBNET.ATG"
+#line 2876 "VBNET.ATG"
AttributeSection section;
List attributes = new List();
TypeReference type = null;
@@ -6967,36 +6968,36 @@ out ParameterDeclarationExpression p) {
while (la.kind == 40) {
AttributeSection(
-#line 2887 "VBNET.ATG"
+#line 2885 "VBNET.ATG"
out section);
-#line 2887 "VBNET.ATG"
+#line 2885 "VBNET.ATG"
attributes.Add(section);
}
while (StartOf(48)) {
ParameterModifier(
-#line 2888 "VBNET.ATG"
+#line 2886 "VBNET.ATG"
mod);
}
Identifier();
-#line 2889 "VBNET.ATG"
+#line 2887 "VBNET.ATG"
string parameterName = t.val;
if (
-#line 2890 "VBNET.ATG"
+#line 2888 "VBNET.ATG"
IsDims()) {
ArrayTypeModifiers(
-#line 2890 "VBNET.ATG"
+#line 2888 "VBNET.ATG"
out arrayModifiers);
}
if (la.kind == 63) {
lexer.NextToken();
TypeName(
-#line 2891 "VBNET.ATG"
+#line 2889 "VBNET.ATG"
out type);
}
-#line 2893 "VBNET.ATG"
+#line 2891 "VBNET.ATG"
if(type != null) {
if (arrayModifiers != null) {
if (type.RankSpecifier != null) {
@@ -7010,11 +7011,11 @@ out type);
if (la.kind == 20) {
lexer.NextToken();
Expr(
-#line 2903 "VBNET.ATG"
+#line 2901 "VBNET.ATG"
out expr);
}
-#line 2905 "VBNET.ATG"
+#line 2903 "VBNET.ATG"
mod.Check();
p = new ParameterDeclarationExpression(type, parameterName, mod.Modifier, expr);
p.Attributes = attributes;
@@ -7022,34 +7023,34 @@ out expr);
}
void ParameterModifier(
-#line 3589 "VBNET.ATG"
+#line 3587 "VBNET.ATG"
ParamModifierList m) {
if (la.kind == 72) {
lexer.NextToken();
-#line 3590 "VBNET.ATG"
+#line 3588 "VBNET.ATG"
m.Add(ParameterModifiers.In);
} else if (la.kind == 69) {
lexer.NextToken();
-#line 3591 "VBNET.ATG"
+#line 3589 "VBNET.ATG"
m.Add(ParameterModifiers.Ref);
} else if (la.kind == 174) {
lexer.NextToken();
-#line 3592 "VBNET.ATG"
+#line 3590 "VBNET.ATG"
m.Add(ParameterModifiers.Optional);
} else if (la.kind == 182) {
lexer.NextToken();
-#line 3593 "VBNET.ATG"
+#line 3591 "VBNET.ATG"
m.Add(ParameterModifiers.Params);
- } else SynErr(310);
+ } else SynErr(311);
}
void Statement() {
-#line 2934 "VBNET.ATG"
+#line 2932 "VBNET.ATG"
Statement stmt = null;
Location startPos = la.Location;
string label = String.Empty;
@@ -7057,27 +7058,27 @@ ParamModifierList m) {
if (la.kind == 1 || la.kind == 21) {
} else if (
-#line 2940 "VBNET.ATG"
+#line 2938 "VBNET.ATG"
IsLabel()) {
LabelName(
-#line 2940 "VBNET.ATG"
+#line 2938 "VBNET.ATG"
out label);
-#line 2942 "VBNET.ATG"
+#line 2940 "VBNET.ATG"
AddChild(new LabelStatement(t.val));
Expect(21);
Statement();
} else if (StartOf(49)) {
EmbeddedStatement(
-#line 2945 "VBNET.ATG"
+#line 2943 "VBNET.ATG"
out stmt);
-#line 2945 "VBNET.ATG"
+#line 2943 "VBNET.ATG"
AddChild(stmt);
- } else SynErr(311);
+ } else SynErr(312);
-#line 2948 "VBNET.ATG"
+#line 2946 "VBNET.ATG"
if (stmt != null) {
stmt.StartLocation = startPos;
stmt.EndLocation = t.Location;
@@ -7086,30 +7087,30 @@ out stmt);
}
void LabelName(
-#line 3363 "VBNET.ATG"
+#line 3361 "VBNET.ATG"
out string name) {
-#line 3365 "VBNET.ATG"
+#line 3363 "VBNET.ATG"
name = String.Empty;
if (StartOf(4)) {
Identifier();
-#line 3367 "VBNET.ATG"
+#line 3365 "VBNET.ATG"
name = t.val;
} else if (la.kind == 5) {
lexer.NextToken();
-#line 3368 "VBNET.ATG"
+#line 3366 "VBNET.ATG"
name = t.val;
- } else SynErr(312);
+ } else SynErr(313);
}
void LocalDeclarationStatement(
-#line 2956 "VBNET.ATG"
+#line 2954 "VBNET.ATG"
out Statement statement) {
-#line 2958 "VBNET.ATG"
+#line 2956 "VBNET.ATG"
ModifierList m = new ModifierList();
LocalVariableDeclaration localVariableDeclaration;
bool dimfound = false;
@@ -7118,22 +7119,22 @@ out Statement statement) {
if (la.kind == 88) {
lexer.NextToken();
-#line 2964 "VBNET.ATG"
+#line 2962 "VBNET.ATG"
m.Add(Modifiers.Const, t.Location);
} else if (la.kind == 204) {
lexer.NextToken();
-#line 2965 "VBNET.ATG"
+#line 2963 "VBNET.ATG"
m.Add(Modifiers.Static, t.Location);
} else {
lexer.NextToken();
-#line 2966 "VBNET.ATG"
+#line 2964 "VBNET.ATG"
dimfound = true;
}
}
-#line 2969 "VBNET.ATG"
+#line 2967 "VBNET.ATG"
if(dimfound && (m.Modifier & Modifiers.Const) != 0) {
Error("Dim is not allowed on constants.");
}
@@ -7146,135 +7147,135 @@ out Statement statement) {
localVariableDeclaration.StartLocation = t.Location;
VariableDeclarator(
-#line 2980 "VBNET.ATG"
+#line 2978 "VBNET.ATG"
localVariableDeclaration.Variables);
while (la.kind == 22) {
lexer.NextToken();
VariableDeclarator(
-#line 2981 "VBNET.ATG"
+#line 2979 "VBNET.ATG"
localVariableDeclaration.Variables);
}
-#line 2983 "VBNET.ATG"
+#line 2981 "VBNET.ATG"
statement = localVariableDeclaration;
}
void TryStatement(
-#line 3477 "VBNET.ATG"
+#line 3475 "VBNET.ATG"
out Statement tryStatement) {
-#line 3479 "VBNET.ATG"
+#line 3477 "VBNET.ATG"
Statement blockStmt = null, finallyStmt = null;List catchClauses = null;
Expect(218);
EndOfStmt();
Block(
-#line 3482 "VBNET.ATG"
+#line 3480 "VBNET.ATG"
out blockStmt);
if (la.kind == 75 || la.kind == 113 || la.kind == 123) {
CatchClauses(
-#line 3483 "VBNET.ATG"
+#line 3481 "VBNET.ATG"
out catchClauses);
}
if (la.kind == 123) {
lexer.NextToken();
EndOfStmt();
Block(
-#line 3484 "VBNET.ATG"
+#line 3482 "VBNET.ATG"
out finallyStmt);
}
Expect(113);
Expect(218);
-#line 3487 "VBNET.ATG"
+#line 3485 "VBNET.ATG"
tryStatement = new TryCatchStatement(blockStmt, catchClauses, finallyStmt);
}
void WithStatement(
-#line 3457 "VBNET.ATG"
+#line 3455 "VBNET.ATG"
out Statement withStatement) {
-#line 3459 "VBNET.ATG"
+#line 3457 "VBNET.ATG"
Statement blockStmt = null;
Expression expr = null;
Expect(233);
-#line 3462 "VBNET.ATG"
+#line 3460 "VBNET.ATG"
Location start = t.Location;
Expr(
-#line 3463 "VBNET.ATG"
+#line 3461 "VBNET.ATG"
out expr);
EndOfStmt();
-#line 3465 "VBNET.ATG"
+#line 3463 "VBNET.ATG"
withStatement = new WithStatement(expr);
withStatement.StartLocation = start;
Block(
-#line 3468 "VBNET.ATG"
+#line 3466 "VBNET.ATG"
out blockStmt);
-#line 3470 "VBNET.ATG"
+#line 3468 "VBNET.ATG"
((WithStatement)withStatement).Body = (BlockStatement)blockStmt;
Expect(113);
Expect(233);
-#line 3473 "VBNET.ATG"
+#line 3471 "VBNET.ATG"
withStatement.EndLocation = t.Location;
}
void WhileOrUntil(
-#line 3450 "VBNET.ATG"
+#line 3448 "VBNET.ATG"
out ConditionType conditionType) {
-#line 3451 "VBNET.ATG"
+#line 3449 "VBNET.ATG"
conditionType = ConditionType.None;
if (la.kind == 231) {
lexer.NextToken();
-#line 3452 "VBNET.ATG"
+#line 3450 "VBNET.ATG"
conditionType = ConditionType.While;
} else if (la.kind == 224) {
lexer.NextToken();
-#line 3453 "VBNET.ATG"
+#line 3451 "VBNET.ATG"
conditionType = ConditionType.Until;
- } else SynErr(313);
+ } else SynErr(314);
}
void LoopControlVariable(
-#line 3293 "VBNET.ATG"
+#line 3291 "VBNET.ATG"
out TypeReference type, out string name) {
-#line 3294 "VBNET.ATG"
+#line 3292 "VBNET.ATG"
ArrayList arrayModifiers = null;
type = null;
Qualident(
-#line 3298 "VBNET.ATG"
+#line 3296 "VBNET.ATG"
out name);
if (
-#line 3299 "VBNET.ATG"
+#line 3297 "VBNET.ATG"
IsDims()) {
ArrayTypeModifiers(
-#line 3299 "VBNET.ATG"
+#line 3297 "VBNET.ATG"
out arrayModifiers);
}
if (la.kind == 63) {
lexer.NextToken();
TypeName(
-#line 3300 "VBNET.ATG"
+#line 3298 "VBNET.ATG"
out type);
-#line 3300 "VBNET.ATG"
+#line 3298 "VBNET.ATG"
if (name.IndexOf('.') > 0) { Error("No type def for 'for each' member indexer allowed."); }
}
-#line 3302 "VBNET.ATG"
+#line 3300 "VBNET.ATG"
if (type != null) {
if(type.RankSpecifier != null && arrayModifiers != null) {
Error("array rank only allowed one time");
@@ -7286,34 +7287,34 @@ out type);
}
void ReDimClause(
-#line 3372 "VBNET.ATG"
+#line 3370 "VBNET.ATG"
out Expression expr) {
SimpleNonInvocationExpression(
-#line 3374 "VBNET.ATG"
+#line 3372 "VBNET.ATG"
out expr);
ReDimClauseInternal(
-#line 3375 "VBNET.ATG"
+#line 3373 "VBNET.ATG"
ref expr);
}
void SingleLineStatementList(
-#line 3279 "VBNET.ATG"
+#line 3277 "VBNET.ATG"
List list) {
-#line 3280 "VBNET.ATG"
+#line 3278 "VBNET.ATG"
Statement embeddedStatement = null;
if (la.kind == 113) {
lexer.NextToken();
-#line 3282 "VBNET.ATG"
+#line 3280 "VBNET.ATG"
embeddedStatement = new EndStatement();
} else if (StartOf(49)) {
EmbeddedStatement(
-#line 3283 "VBNET.ATG"
+#line 3281 "VBNET.ATG"
out embeddedStatement);
- } else SynErr(314);
+ } else SynErr(315);
-#line 3284 "VBNET.ATG"
+#line 3282 "VBNET.ATG"
if (embeddedStatement != null) list.Add(embeddedStatement);
while (la.kind == 21) {
lexer.NextToken();
@@ -7323,62 +7324,62 @@ out embeddedStatement);
if (la.kind == 113) {
lexer.NextToken();
-#line 3286 "VBNET.ATG"
+#line 3284 "VBNET.ATG"
embeddedStatement = new EndStatement();
} else if (StartOf(49)) {
EmbeddedStatement(
-#line 3287 "VBNET.ATG"
+#line 3285 "VBNET.ATG"
out embeddedStatement);
- } else SynErr(315);
+ } else SynErr(316);
-#line 3288 "VBNET.ATG"
+#line 3286 "VBNET.ATG"
if (embeddedStatement != null) list.Add(embeddedStatement);
}
}
void CaseClauses(
-#line 3410 "VBNET.ATG"
+#line 3408 "VBNET.ATG"
out List caseClauses) {
-#line 3412 "VBNET.ATG"
+#line 3410 "VBNET.ATG"
caseClauses = new List();
CaseLabel caseClause = null;
CaseClause(
-#line 3415 "VBNET.ATG"
+#line 3413 "VBNET.ATG"
out caseClause);
-#line 3415 "VBNET.ATG"
+#line 3413 "VBNET.ATG"
if (caseClause != null) { caseClauses.Add(caseClause); }
while (la.kind == 22) {
lexer.NextToken();
CaseClause(
-#line 3416 "VBNET.ATG"
+#line 3414 "VBNET.ATG"
out caseClause);
-#line 3416 "VBNET.ATG"
+#line 3414 "VBNET.ATG"
if (caseClause != null) { caseClauses.Add(caseClause); }
}
}
void OnErrorStatement(
-#line 3313 "VBNET.ATG"
+#line 3311 "VBNET.ATG"
out OnErrorStatement stmt) {
-#line 3315 "VBNET.ATG"
+#line 3313 "VBNET.ATG"
stmt = null;
GotoStatement goToStatement = null;
Expect(171);
Expect(118);
if (
-#line 3321 "VBNET.ATG"
+#line 3319 "VBNET.ATG"
IsNegativeLabelName()) {
Expect(132);
Expect(30);
Expect(5);
-#line 3323 "VBNET.ATG"
+#line 3321 "VBNET.ATG"
long intLabel = Int64.Parse(t.val);
if(intLabel != 1) {
Error("invalid label in on error statement.");
@@ -7387,10 +7388,10 @@ IsNegativeLabelName()) {
} else if (la.kind == 132) {
GotoStatement(
-#line 3329 "VBNET.ATG"
+#line 3327 "VBNET.ATG"
out goToStatement);
-#line 3331 "VBNET.ATG"
+#line 3329 "VBNET.ATG"
string val = goToStatement.Label;
// if value is numeric, make sure that is 0
@@ -7407,88 +7408,88 @@ out goToStatement);
lexer.NextToken();
Expect(163);
-#line 3345 "VBNET.ATG"
+#line 3343 "VBNET.ATG"
stmt = new OnErrorStatement(new ResumeStatement(true));
- } else SynErr(316);
+ } else SynErr(317);
}
void GotoStatement(
-#line 3351 "VBNET.ATG"
+#line 3349 "VBNET.ATG"
out GotoStatement goToStatement) {
-#line 3353 "VBNET.ATG"
+#line 3351 "VBNET.ATG"
string label = String.Empty;
Expect(132);
LabelName(
-#line 3356 "VBNET.ATG"
+#line 3354 "VBNET.ATG"
out label);
-#line 3358 "VBNET.ATG"
+#line 3356 "VBNET.ATG"
goToStatement = new GotoStatement(label);
}
void ResumeStatement(
-#line 3399 "VBNET.ATG"
+#line 3397 "VBNET.ATG"
out ResumeStatement resumeStatement) {
-#line 3401 "VBNET.ATG"
+#line 3399 "VBNET.ATG"
resumeStatement = null;
string label = String.Empty;
if (
-#line 3404 "VBNET.ATG"
+#line 3402 "VBNET.ATG"
IsResumeNext()) {
Expect(194);
Expect(163);
-#line 3405 "VBNET.ATG"
+#line 3403 "VBNET.ATG"
resumeStatement = new ResumeStatement(true);
} else if (la.kind == 194) {
lexer.NextToken();
if (StartOf(50)) {
LabelName(
-#line 3406 "VBNET.ATG"
+#line 3404 "VBNET.ATG"
out label);
}
-#line 3406 "VBNET.ATG"
+#line 3404 "VBNET.ATG"
resumeStatement = new ResumeStatement(label);
- } else SynErr(317);
+ } else SynErr(318);
}
void ReDimClauseInternal(
-#line 3378 "VBNET.ATG"
+#line 3376 "VBNET.ATG"
ref Expression expr) {
-#line 3379 "VBNET.ATG"
+#line 3377 "VBNET.ATG"
List arguments; bool canBeNormal; bool canBeRedim; string name;
while (la.kind == 26 ||
-#line 3382 "VBNET.ATG"
+#line 3380 "VBNET.ATG"
la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
if (la.kind == 26) {
lexer.NextToken();
IdentifierOrKeyword(
-#line 3381 "VBNET.ATG"
+#line 3379 "VBNET.ATG"
out name);
-#line 3381 "VBNET.ATG"
+#line 3379 "VBNET.ATG"
expr = new MemberReferenceExpression(expr, name);
} else {
InvocationExpression(
-#line 3383 "VBNET.ATG"
+#line 3381 "VBNET.ATG"
ref expr);
}
}
Expect(37);
NormalOrReDimArgumentList(
-#line 3386 "VBNET.ATG"
+#line 3384 "VBNET.ATG"
out arguments, out canBeNormal, out canBeRedim);
Expect(38);
-#line 3388 "VBNET.ATG"
+#line 3386 "VBNET.ATG"
expr = new InvocationExpression(expr, arguments);
if (canBeRedim == false || canBeNormal && (la.kind == Tokens.Dot || la.kind == Tokens.OpenParenthesis)) {
if (this.Errors.Count == 0) {
@@ -7500,10 +7501,10 @@ out arguments, out canBeNormal, out canBeRedim);
}
void CaseClause(
-#line 3420 "VBNET.ATG"
+#line 3418 "VBNET.ATG"
out CaseLabel caseClause) {
-#line 3422 "VBNET.ATG"
+#line 3420 "VBNET.ATG"
Expression expr = null;
Expression sexpr = null;
BinaryOperatorType op = BinaryOperatorType.None;
@@ -7512,7 +7513,7 @@ out CaseLabel caseClause) {
if (la.kind == 111) {
lexer.NextToken();
-#line 3428 "VBNET.ATG"
+#line 3426 "VBNET.ATG"
caseClause = new CaseLabel();
} else if (StartOf(51)) {
if (la.kind == 144) {
@@ -7522,76 +7523,76 @@ out CaseLabel caseClause) {
case 40: {
lexer.NextToken();
-#line 3432 "VBNET.ATG"
+#line 3430 "VBNET.ATG"
op = BinaryOperatorType.LessThan;
break;
}
case 39: {
lexer.NextToken();
-#line 3433 "VBNET.ATG"
+#line 3431 "VBNET.ATG"
op = BinaryOperatorType.GreaterThan;
break;
}
case 43: {
lexer.NextToken();
-#line 3434 "VBNET.ATG"
+#line 3432 "VBNET.ATG"
op = BinaryOperatorType.LessThanOrEqual;
break;
}
case 42: {
lexer.NextToken();
-#line 3435 "VBNET.ATG"
+#line 3433 "VBNET.ATG"
op = BinaryOperatorType.GreaterThanOrEqual;
break;
}
case 20: {
lexer.NextToken();
-#line 3436 "VBNET.ATG"
+#line 3434 "VBNET.ATG"
op = BinaryOperatorType.Equality;
break;
}
case 41: {
lexer.NextToken();
-#line 3437 "VBNET.ATG"
+#line 3435 "VBNET.ATG"
op = BinaryOperatorType.InEquality;
break;
}
- default: SynErr(318); break;
+ default: SynErr(319); break;
}
Expr(
-#line 3439 "VBNET.ATG"
+#line 3437 "VBNET.ATG"
out expr);
-#line 3441 "VBNET.ATG"
+#line 3439 "VBNET.ATG"
caseClause = new CaseLabel(op, expr);
} else if (StartOf(29)) {
Expr(
-#line 3443 "VBNET.ATG"
+#line 3441 "VBNET.ATG"
out expr);
if (la.kind == 216) {
lexer.NextToken();
Expr(
-#line 3443 "VBNET.ATG"
+#line 3441 "VBNET.ATG"
out sexpr);
}
-#line 3445 "VBNET.ATG"
+#line 3443 "VBNET.ATG"
caseClause = new CaseLabel(expr, sexpr);
- } else SynErr(319);
+ } else SynErr(320);
}
void CatchClauses(
-#line 3492 "VBNET.ATG"
+#line 3490 "VBNET.ATG"
out List catchClauses) {
-#line 3494 "VBNET.ATG"
+#line 3492 "VBNET.ATG"
catchClauses = new List();
TypeReference type = null;
Statement blockStmt = null;
@@ -7603,27 +7604,27 @@ out List catchClauses) {
if (StartOf(4)) {
Identifier();
-#line 3502 "VBNET.ATG"
+#line 3500 "VBNET.ATG"
name = t.val;
if (la.kind == 63) {
lexer.NextToken();
TypeName(
-#line 3502 "VBNET.ATG"
+#line 3500 "VBNET.ATG"
out type);
}
}
if (la.kind == 229) {
lexer.NextToken();
Expr(
-#line 3503 "VBNET.ATG"
+#line 3501 "VBNET.ATG"
out expr);
}
EndOfStmt();
Block(
-#line 3505 "VBNET.ATG"
+#line 3503 "VBNET.ATG"
out blockStmt);
-#line 3506 "VBNET.ATG"
+#line 3504 "VBNET.ATG"
catchClauses.Add(new CatchClause(type, name, blockStmt, expr));
}
}
@@ -7879,23 +7880,23 @@ out blockStmt);
case 236: s = "\"Xor\" expected"; break;
case 237: s = "\"GetXmlNamespace\" expected"; break;
case 238: s = "??? expected"; break;
- case 239: s = "invalid EndOfStmt"; break;
- case 240: s = "invalid OptionStmt"; break;
+ case 239: s = "this symbol not expected in EndOfStmt"; break;
+ case 240: s = "invalid EndOfStmt"; break;
case 241: s = "invalid OptionStmt"; break;
- case 242: s = "invalid GlobalAttributeSection"; break;
+ case 242: s = "invalid OptionStmt"; break;
case 243: s = "invalid GlobalAttributeSection"; break;
- case 244: s = "invalid NamespaceMemberDecl"; break;
- case 245: s = "invalid OptionValue"; break;
- case 246: s = "invalid ImportClause"; break;
- case 247: s = "invalid Identifier"; break;
- case 248: s = "invalid TypeModifier"; break;
- case 249: s = "invalid NonModuleDeclaration"; break;
+ case 244: s = "invalid GlobalAttributeSection"; break;
+ case 245: s = "invalid NamespaceMemberDecl"; break;
+ case 246: s = "invalid OptionValue"; break;
+ case 247: s = "invalid ImportClause"; break;
+ case 248: s = "invalid Identifier"; break;
+ case 249: s = "invalid TypeModifier"; break;
case 250: s = "invalid NonModuleDeclaration"; break;
- case 251: s = "invalid TypeParameterConstraints"; break;
- case 252: s = "invalid TypeParameterConstraint"; break;
- case 253: s = "invalid NonArrayTypeName"; break;
- case 254: s = "invalid MemberModifier"; break;
- case 255: s = "invalid StructureMemberDecl"; break;
+ case 251: s = "invalid NonModuleDeclaration"; break;
+ case 252: s = "invalid TypeParameterConstraints"; break;
+ case 253: s = "invalid TypeParameterConstraint"; break;
+ case 254: s = "invalid NonArrayTypeName"; break;
+ case 255: s = "invalid MemberModifier"; break;
case 256: s = "invalid StructureMemberDecl"; break;
case 257: s = "invalid StructureMemberDecl"; break;
case 258: s = "invalid StructureMemberDecl"; break;
@@ -7903,63 +7904,64 @@ out blockStmt);
case 260: s = "invalid StructureMemberDecl"; break;
case 261: s = "invalid StructureMemberDecl"; break;
case 262: s = "invalid StructureMemberDecl"; break;
- case 263: s = "invalid InterfaceMemberDecl"; break;
+ case 263: s = "invalid StructureMemberDecl"; break;
case 264: s = "invalid InterfaceMemberDecl"; break;
- case 265: s = "invalid Expr"; break;
- case 266: s = "invalid Charset"; break;
- case 267: s = "invalid IdentifierForFieldDeclaration"; break;
- case 268: s = "invalid VariableDeclaratorPartAfterIdentifier"; break;
- case 269: s = "invalid AccessorDecls"; break;
- case 270: s = "invalid EventAccessorDeclaration"; break;
- case 271: s = "invalid OverloadableOperator"; break;
- case 272: s = "invalid EventMemberSpecifier"; break;
- case 273: s = "invalid LambdaExpr"; break;
- case 274: s = "invalid AssignmentOperator"; break;
- case 275: s = "invalid SimpleExpr"; break;
+ case 265: s = "invalid InterfaceMemberDecl"; break;
+ case 266: s = "invalid Expr"; break;
+ case 267: s = "invalid Charset"; break;
+ case 268: s = "invalid IdentifierForFieldDeclaration"; break;
+ case 269: s = "invalid VariableDeclaratorPartAfterIdentifier"; break;
+ case 270: s = "invalid AccessorDecls"; break;
+ case 271: s = "invalid EventAccessorDeclaration"; break;
+ case 272: s = "invalid OverloadableOperator"; break;
+ case 273: s = "invalid EventMemberSpecifier"; break;
+ case 274: s = "invalid LambdaExpr"; break;
+ case 275: s = "invalid AssignmentOperator"; break;
case 276: s = "invalid SimpleExpr"; break;
- case 277: s = "invalid SimpleNonInvocationExpression"; break;
+ case 277: s = "invalid SimpleExpr"; break;
case 278: s = "invalid SimpleNonInvocationExpression"; break;
case 279: s = "invalid SimpleNonInvocationExpression"; break;
case 280: s = "invalid SimpleNonInvocationExpression"; break;
case 281: s = "invalid SimpleNonInvocationExpression"; break;
case 282: s = "invalid SimpleNonInvocationExpression"; break;
- case 283: s = "invalid PrimitiveTypeName"; break;
- case 284: s = "invalid CastTarget"; break;
- case 285: s = "invalid XmlLiteralExpression"; break;
- case 286: s = "invalid XmlContentExpression"; break;
- case 287: s = "invalid XmlElement"; break;
+ case 283: s = "invalid SimpleNonInvocationExpression"; break;
+ case 284: s = "invalid PrimitiveTypeName"; break;
+ case 285: s = "invalid CastTarget"; break;
+ case 286: s = "invalid XmlLiteralExpression"; break;
+ case 287: s = "invalid XmlContentExpression"; break;
case 288: s = "invalid XmlElement"; break;
- case 289: s = "invalid XmlNestedContent"; break;
- case 290: s = "invalid XmlAttribute"; break;
+ case 289: s = "invalid XmlElement"; break;
+ case 290: s = "invalid XmlNestedContent"; break;
case 291: s = "invalid XmlAttribute"; break;
- case 292: s = "invalid ComparisonExpr"; break;
- case 293: s = "invalid SubLambdaExpression"; break;
- case 294: s = "invalid FunctionLambdaExpression"; break;
- case 295: s = "invalid EmbeddedStatement"; break;
+ case 292: s = "invalid XmlAttribute"; break;
+ case 293: s = "invalid ComparisonExpr"; break;
+ case 294: s = "invalid SubLambdaExpression"; break;
+ case 295: s = "invalid FunctionLambdaExpression"; break;
case 296: s = "invalid EmbeddedStatement"; break;
case 297: s = "invalid EmbeddedStatement"; break;
case 298: s = "invalid EmbeddedStatement"; break;
case 299: s = "invalid EmbeddedStatement"; break;
case 300: s = "invalid EmbeddedStatement"; break;
case 301: s = "invalid EmbeddedStatement"; break;
- case 302: s = "invalid FromOrAggregateQueryOperator"; break;
- case 303: s = "invalid QueryOperator"; break;
- case 304: s = "invalid PartitionQueryOperator"; break;
- case 305: s = "invalid Argument"; break;
- case 306: s = "invalid QualIdentAndTypeArguments"; break;
- case 307: s = "invalid AttributeArguments"; break;
+ case 302: s = "invalid EmbeddedStatement"; break;
+ case 303: s = "invalid FromOrAggregateQueryOperator"; break;
+ case 304: s = "invalid QueryOperator"; break;
+ case 305: s = "invalid PartitionQueryOperator"; break;
+ case 306: s = "invalid Argument"; break;
+ case 307: s = "invalid QualIdentAndTypeArguments"; break;
case 308: s = "invalid AttributeArguments"; break;
case 309: s = "invalid AttributeArguments"; break;
- case 310: s = "invalid ParameterModifier"; break;
- case 311: s = "invalid Statement"; break;
- case 312: s = "invalid LabelName"; break;
- case 313: s = "invalid WhileOrUntil"; break;
- case 314: s = "invalid SingleLineStatementList"; break;
+ case 310: s = "invalid AttributeArguments"; break;
+ case 311: s = "invalid ParameterModifier"; break;
+ case 312: s = "invalid Statement"; break;
+ case 313: s = "invalid LabelName"; break;
+ case 314: s = "invalid WhileOrUntil"; break;
case 315: s = "invalid SingleLineStatementList"; break;
- case 316: s = "invalid OnErrorStatement"; break;
- case 317: s = "invalid ResumeStatement"; break;
- case 318: s = "invalid CaseClause"; break;
+ case 316: s = "invalid SingleLineStatementList"; break;
+ case 317: s = "invalid OnErrorStatement"; break;
+ case 318: s = "invalid ResumeStatement"; break;
case 319: s = "invalid CaseClause"; break;
+ case 320: s = "invalid CaseClause"; break;
default: s = "error " + errorNumber; break;
}
@@ -7972,7 +7974,7 @@ out blockStmt);
}
static bool[,] set = {
- {T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
+ {T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, T,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,T,x,T, T,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,T,x,T, T,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,T,x,T, T,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
diff --git a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG
index 1a694b71e1..811a5abf36 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG
+++ b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG
@@ -307,9 +307,7 @@ OptionValue[ =
.
EndOfStmt =
- EOL
-|
- ":"
+ SYNC ( EOL | ":" )
.
ImportsStmt
diff --git a/src/Main/Base/Project/Src/Editor/CodeCompletion/IInsightWindow.cs b/src/Main/Base/Project/Src/Editor/CodeCompletion/IInsightWindow.cs
index 31c1b4bbda..3310ffe8a2 100644
--- a/src/Main/Base/Project/Src/Editor/CodeCompletion/IInsightWindow.cs
+++ b/src/Main/Base/Project/Src/Editor/CodeCompletion/IInsightWindow.cs
@@ -34,5 +34,9 @@ namespace ICSharpCode.SharpDevelop.Editor.CodeCompletion
/// when the insight window is closed. This makes it easier to avoid memory leaks.
///
event EventHandler DocumentChanged;
+
+ event EventHandler SelectedItemChanged;
+
+ event EventHandler CaretPositionChanged;
}
}
diff --git a/src/Main/Base/Project/Src/Editor/CodeCompletion/NRefactoryInsightWindowHandler.cs b/src/Main/Base/Project/Src/Editor/CodeCompletion/NRefactoryInsightWindowHandler.cs
index 16d16f8cf4..26b6dfd757 100644
--- a/src/Main/Base/Project/Src/Editor/CodeCompletion/NRefactoryInsightWindowHandler.cs
+++ b/src/Main/Base/Project/Src/Editor/CodeCompletion/NRefactoryInsightWindowHandler.cs
@@ -81,6 +81,7 @@ namespace ICSharpCode.SharpDevelop.Editor.CodeCompletion
}
};
insightWindow.DocumentChanged += onDocumentChanged;
+ insightWindow.SelectedItemChanged += delegate { HighlightParameter(insightWindow, HighlightedParameter); };
onDocumentChanged(null, null);
}
@@ -277,12 +278,15 @@ namespace ICSharpCode.SharpDevelop.Editor.CodeCompletion
}
}
+ public int HighlightedParameter { get; set; }
+
public void HighlightParameter(IInsightWindow window, int index)
{
var item = window.SelectedItem as MethodInsightItem;
if (item != null)
item.HighlightParameter = index;
+ HighlightedParameter = index;
}
}
}
]