From ef076ee0601031e2997ee68ad86a56368acaf746 Mon Sep 17 00:00:00 2001 From: Daniel Grunwald Date: Sat, 16 Jul 2005 16:52:58 +0000 Subject: [PATCH] Improved C# <-> VB.Net conversion. git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@188 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61 --- src/Libraries/NRefactory/NRefactory.sln | 2 +- .../NRefactory/Project/NRefactory.csproj | 3 + .../Src/Output/CSharp/CSharpOutputVisitor.cs | 50 +- .../Output/CodeDOM/CodeDOMOutputVisitor.cs | 82 +- .../Src/Output/VBNet/VBNetOutputVisitor.cs | 24 +- .../Expressions/BinaryOperatorExpression.cs | 42 +- .../Statements/LocalVariableDeclaration.cs | 6 +- .../AST/General/TypeLevel/EventDeclaration.cs | 10 +- .../AST/General/TypeLevel/FieldDeclaration.cs | 6 +- .../General/TypeLevel/PropertyGetSetRegion.cs | 3 + .../Project/Src/Parser/CSharp/Parser.cs | 8 +- .../Project/Src/Parser/CSharp/cs.ATG | 8 +- .../Project/Src/Parser/Frames/trace.txt | 4608 ++++++++--------- .../Project/Src/Parser/VBNet/Parser.cs | 2131 ++++---- .../Project/Src/Parser/VBNet/VBNET.ATG | 13 +- .../Visitors/CSharpToVBNetConvertVisitor.cs | 88 + .../Parser/Visitors/PrefixFieldsVisitor.cs | 170 + .../Visitors/VBNetToCSharpConvertVisitor.cs | 58 + .../VBConverter/CSharpConvertBuffer.cs | 1 + .../Src/Commands/VBConverter/ConvertBuffer.cs | 1 + 20 files changed, 3855 insertions(+), 3459 deletions(-) create mode 100644 src/Libraries/NRefactory/Project/Src/Parser/Visitors/CSharpToVBNetConvertVisitor.cs create mode 100644 src/Libraries/NRefactory/Project/Src/Parser/Visitors/PrefixFieldsVisitor.cs create mode 100644 src/Libraries/NRefactory/Project/Src/Parser/Visitors/VBNetToCSharpConvertVisitor.cs diff --git a/src/Libraries/NRefactory/NRefactory.sln b/src/Libraries/NRefactory/NRefactory.sln index fe7c7afcd3..e3fd317960 100644 --- a/src/Libraries/NRefactory/NRefactory.sln +++ b/src/Libraries/NRefactory/NRefactory.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 9.00 -# Visual Studio 2005 +# SharpDevelop 2.0.0.1 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactory", "Project\NRefactory.csproj", "{3A9AE6AA-BC07-4A2F-972C-581E3AE2F195}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactoryTests", "Test\NRefactoryTests.csproj", "{870115DD-960A-4406-A6B9-600BCDC36A03}" diff --git a/src/Libraries/NRefactory/Project/NRefactory.csproj b/src/Libraries/NRefactory/Project/NRefactory.csproj index 21840dd3b4..fb371de851 100644 --- a/src/Libraries/NRefactory/Project/NRefactory.csproj +++ b/src/Libraries/NRefactory/Project/NRefactory.csproj @@ -185,6 +185,9 @@ + + + diff --git a/src/Libraries/NRefactory/Project/Src/Output/CSharp/CSharpOutputVisitor.cs b/src/Libraries/NRefactory/Project/Src/Output/CSharp/CSharpOutputVisitor.cs index 683585542c..0b5c2f1445 100644 --- a/src/Libraries/NRefactory/Project/Src/Output/CSharp/CSharpOutputVisitor.cs +++ b/src/Libraries/NRefactory/Project/Src/Output/CSharp/CSharpOutputVisitor.cs @@ -824,7 +824,16 @@ namespace ICSharpCode.NRefactory.PrettyPrinter public object Visit(EraseStatement eraseStatement, object data) { - errors.Error(-1, -1, String.Format("EraseStatement is unsupported")); + foreach (Expression expr in eraseStatement.Expressions) { + outputFormatter.Indent(); + expr.AcceptVisitor(this, data); + outputFormatter.Space(); + outputFormatter.PrintToken(Tokens.Assign); + outputFormatter.Space(); + outputFormatter.PrintToken(Tokens.Null); + outputFormatter.PrintToken(Tokens.Semicolon); + outputFormatter.NewLine(); + } return null; } @@ -1108,7 +1117,7 @@ namespace ICSharpCode.NRefactory.PrettyPrinter public object Visit(StopStatement stopStatement, object data) { - outputFormatter.PrintIdentifier("Debugger.Break()"); + outputFormatter.PrintIdentifier("System.Diagnostics.Debugger.Break()"); outputFormatter.PrintToken(Tokens.Semicolon); return null; } @@ -1441,8 +1450,38 @@ namespace ICSharpCode.NRefactory.PrettyPrinter return null; } + bool IsNullLiteralExpression(Expression expr) + { + PrimitiveExpression pe = expr as PrimitiveExpression; + if (pe == null) return false; + return pe.Value == null; + } + public object Visit(BinaryOperatorExpression binaryOperatorExpression, object data) { + // VB-operators that require special representation: + switch (binaryOperatorExpression.Op) { + case BinaryOperatorType.ReferenceEquality: + case BinaryOperatorType.ReferenceInequality: + if (IsNullLiteralExpression(binaryOperatorExpression.Left) || IsNullLiteralExpression(binaryOperatorExpression.Right)) { + // prefer a == null to object.ReferenceEquals(a, null) + break; + } + + if (binaryOperatorExpression.Op == BinaryOperatorType.ReferenceInequality) + outputFormatter.PrintToken(Tokens.Not); + outputFormatter.PrintIdentifier("object.ReferenceEquals"); + if (prettyPrintOptions.BeforeMethodCallParentheses) { + outputFormatter.Space(); + } + + outputFormatter.PrintToken(Tokens.OpenParenthesis); + nodeTracker.TrackedVisit(binaryOperatorExpression.Left, data); + PrintFormattedComma(); + nodeTracker.TrackedVisit(binaryOperatorExpression.Right, data); + outputFormatter.PrintToken(Tokens.CloseParenthesis); + return null; + } nodeTracker.TrackedVisit(binaryOperatorExpression.Left, data); switch (binaryOperatorExpression.Op) { case BinaryOperatorType.Add: @@ -1476,6 +1515,7 @@ namespace ICSharpCode.NRefactory.PrettyPrinter break; case BinaryOperatorType.Divide: + case BinaryOperatorType.DivideInteger: if (prettyPrintOptions.AroundMultiplicativeOperatorParentheses) { outputFormatter.Space(); } @@ -1563,19 +1603,20 @@ namespace ICSharpCode.NRefactory.PrettyPrinter } break; - case BinaryOperatorType.AS: + case BinaryOperatorType.AsCast: outputFormatter.Space(); outputFormatter.PrintToken(Tokens.As); outputFormatter.Space(); break; - case BinaryOperatorType.IS: + case BinaryOperatorType.TypeCheck: outputFormatter.Space(); outputFormatter.PrintToken(Tokens.Is); outputFormatter.Space(); break; case BinaryOperatorType.Equality: + case BinaryOperatorType.ReferenceEquality: if (prettyPrintOptions.AroundRelationalOperatorParentheses) { outputFormatter.Space(); } @@ -1603,6 +1644,7 @@ namespace ICSharpCode.NRefactory.PrettyPrinter } break; case BinaryOperatorType.InEquality: + case BinaryOperatorType.ReferenceInequality: if (prettyPrintOptions.AroundRelationalOperatorParentheses) { outputFormatter.Space(); } diff --git a/src/Libraries/NRefactory/Project/Src/Output/CodeDOM/CodeDOMOutputVisitor.cs b/src/Libraries/NRefactory/Project/Src/Output/CodeDOM/CodeDOMOutputVisitor.cs index 7d88188250..0d6572fd5b 100644 --- a/src/Libraries/NRefactory/Project/Src/Output/CodeDOM/CodeDOMOutputVisitor.cs +++ b/src/Libraries/NRefactory/Project/Src/Output/CodeDOM/CodeDOMOutputVisitor.cs @@ -89,7 +89,7 @@ namespace ICSharpCode.NRefactory.Parser } } - string ConvType(string type) + string ConvType(string type) { if (type == null) { return null; @@ -121,7 +121,7 @@ namespace ICSharpCode.NRefactory.Parser } // FIXME: map all modifiers correctly - MemberAttributes ConvMemberAttributes(Modifier modifier) + MemberAttributes ConvMemberAttributes(Modifier modifier) { MemberAttributes attr = (MemberAttributes)0; @@ -161,7 +161,7 @@ namespace ICSharpCode.NRefactory.Parser return attr; } -#region ICSharpCode.SharpRefactory.Parser.IASTVisitor interface implementation + #region ICSharpCode.SharpRefactory.Parser.IASTVisitor interface implementation public override object Visit(CompilationUnit compilationUnit, object data) { if (compilationUnit == null) { @@ -236,7 +236,7 @@ namespace ICSharpCode.NRefactory.Parser { // CodeTypeDelegate codeTypeDelegate = new CodeTypeDelegate(delegateDeclaration.Name); // codeTypeDelegate.Parameters -// +// // ((CodeNamespace)namespaceDeclarations.Peek()).Types.Add(codeTypeDelegate); return null; } @@ -349,11 +349,11 @@ namespace ICSharpCode.NRefactory.Parser VariableDeclaration var = (VariableDeclaration)localVariableDeclaration.Variables[i]; if (!var.Initializer.IsNull) { declStmt = new CodeVariableDeclarationStatement(type, - var.Name, - (CodeExpression)((INode)var.Initializer).AcceptVisitor(this, data)); + var.Name, + (CodeExpression)((INode)var.Initializer).AcceptVisitor(this, data)); } else { declStmt = new CodeVariableDeclarationStatement(type, - var.Name); + var.Name); } } @@ -499,7 +499,7 @@ namespace ICSharpCode.NRefactory.Parser codeStack.Pop(); } - foreach (CatchClause clause in tryCatchStatement.CatchClauses) + foreach (CatchClause clause in tryCatchStatement.CatchClauses) { CodeCatchClause catchClause = new CodeCatchClause(clause.VariableName); catchClause.CatchExceptionType = new CodeTypeReference(clause.TypeReference.Type); @@ -558,6 +558,7 @@ namespace ICSharpCode.NRefactory.Parser op = CodeBinaryOperatorType.BooleanOr; break; case BinaryOperatorType.Divide: + case BinaryOperatorType.DivideInteger: op = CodeBinaryOperatorType.Divide; break; case BinaryOperatorType.GreaterThan: @@ -587,23 +588,26 @@ namespace ICSharpCode.NRefactory.Parser case BinaryOperatorType.Subtract: op = CodeBinaryOperatorType.Subtract; break; - case BinaryOperatorType.ValueEquality: - op = CodeBinaryOperatorType.ValueEquality; - break; + //case BinaryOperatorType.ValueEquality: + // op = CodeBinaryOperatorType.ValueEquality; + // break; case BinaryOperatorType.ShiftLeft: - // CodeDOM suxx - op = CodeBinaryOperatorType.Multiply; - break; case BinaryOperatorType.ShiftRight: // CodeDOM suxx op = CodeBinaryOperatorType.Multiply; break; - case BinaryOperatorType.IS: + case BinaryOperatorType.ReferenceEquality: op = CodeBinaryOperatorType.IdentityEquality; break; - case BinaryOperatorType.AS: - op = CodeBinaryOperatorType.IdentityEquality; + case BinaryOperatorType.ReferenceInequality: + op = CodeBinaryOperatorType.IdentityInequality; + break; + case BinaryOperatorType.AsCast: + case BinaryOperatorType.TypeCheck: + // CodeDOM suxx + op = CodeBinaryOperatorType.Add; break; + case BinaryOperatorType.ExclusiveOr: // TODO ExclusiveOr op = CodeBinaryOperatorType.BitwiseAnd; @@ -633,7 +637,7 @@ namespace ICSharpCode.NRefactory.Parser FieldReferenceExpression fRef2 = (FieldReferenceExpression)fRef.TargetObject; if (fRef2.FieldName != null && Char.IsUpper(fRef2.FieldName[0])) { // an exception is thrown if it doesn't end in an indentifier exception - // for example for : this.MyObject.MyMethod() leads to an exception, which + // for example for : this.MyObject.MyMethod() leads to an exception, which // is correct in this case ... I know this is really HACKY :) try { CodeExpression tExpr = ConvertToIdentifier(fRef2); @@ -691,10 +695,10 @@ namespace ICSharpCode.NRefactory.Parser return new CodePrimitiveExpression(- (float)expression.Value); } - } + } return new CodeBinaryOperatorExpression(new CodePrimitiveExpression(0), - CodeBinaryOperatorType.Subtract, - (CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data)); + CodeBinaryOperatorType.Subtract, + (CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data)); case UnaryOperatorType.Plus: return unaryOperatorExpression.Expression.AcceptVisitor(this, data); @@ -703,36 +707,36 @@ namespace ICSharpCode.NRefactory.Parser var = (CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data); return new CodeAssignStatement(var, - new CodeBinaryOperatorExpression(var, - CodeBinaryOperatorType.Add, - new CodePrimitiveExpression(1))); + new CodeBinaryOperatorExpression(var, + CodeBinaryOperatorType.Add, + new CodePrimitiveExpression(1))); case UnaryOperatorType.PostDecrement: // emulate i--, with i = i - 1 var = (CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data); return new CodeAssignStatement(var, - new CodeBinaryOperatorExpression(var, - CodeBinaryOperatorType.Subtract, - new CodePrimitiveExpression(1))); + new CodeBinaryOperatorExpression(var, + CodeBinaryOperatorType.Subtract, + new CodePrimitiveExpression(1))); case UnaryOperatorType.Decrement: // emulate --i, with i = i - 1 var = (CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data); return new CodeAssignStatement(var, - new CodeBinaryOperatorExpression(var, - CodeBinaryOperatorType.Subtract, - new CodePrimitiveExpression(1))); + new CodeBinaryOperatorExpression(var, + CodeBinaryOperatorType.Subtract, + new CodePrimitiveExpression(1))); case UnaryOperatorType.Increment: // emulate ++i, with i = i + 1 var = (CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data); return new CodeAssignStatement(var, - new CodeBinaryOperatorExpression(var, - CodeBinaryOperatorType.Add, - new CodePrimitiveExpression(1))); + new CodeBinaryOperatorExpression(var, + CodeBinaryOperatorType.Add, + new CodePrimitiveExpression(1))); } return null; @@ -745,15 +749,15 @@ namespace ICSharpCode.NRefactory.Parser methodReference = true; CodeExpression methodInvoker = (CodeExpression)assignmentExpression.Right.AcceptVisitor(this, null); methodReference = false; - + if (assignmentExpression.Left is IdentifierExpression) { AddStmt(new CodeAttachEventStatement(new CodeEventReferenceExpression(new CodeThisReferenceExpression(), ((IdentifierExpression)assignmentExpression.Left).Identifier), - methodInvoker)); + methodInvoker)); } else { FieldReferenceExpression fr = (FieldReferenceExpression)assignmentExpression.Left; AddStmt(new CodeAttachEventStatement(new CodeEventReferenceExpression((CodeExpression)fr.TargetObject.AcceptVisitor(this, data), fr.FieldName), - methodInvoker)); + methodInvoker)); } } else { if (assignmentExpression.Left is IdentifierExpression) { @@ -765,7 +769,7 @@ namespace ICSharpCode.NRefactory.Parser return null; } - + public override object Visit(TypeOfExpression typeOfExpression, object data) { return new CodeTypeOfExpression(ConvType(typeOfExpression.TypeReference.Type)); @@ -957,10 +961,10 @@ namespace ICSharpCode.NRefactory.Parser Type GetType(string typeName) { - foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies()) + foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies()) { Type type = asm.GetType(typeName); - if (type != null) + if (type != null) { return type; } diff --git a/src/Libraries/NRefactory/Project/Src/Output/VBNet/VBNetOutputVisitor.cs b/src/Libraries/NRefactory/Project/Src/Output/VBNet/VBNetOutputVisitor.cs index 3d6efc59f6..809df6c0a6 100644 --- a/src/Libraries/NRefactory/Project/Src/Output/VBNet/VBNetOutputVisitor.cs +++ b/src/Libraries/NRefactory/Project/Src/Output/VBNet/VBNetOutputVisitor.cs @@ -499,7 +499,7 @@ namespace ICSharpCode.NRefactory.PrettyPrinter { VisitAttributes(propertySetRegion.Attributes, data); outputFormatter.Indent(); - outputFormatter.PrintToken(Tokens.Get); + outputFormatter.PrintToken(Tokens.Set); outputFormatter.NewLine(); ++outputFormatter.IndentationLevel; @@ -508,7 +508,7 @@ namespace ICSharpCode.NRefactory.PrettyPrinter outputFormatter.Indent(); outputFormatter.PrintToken(Tokens.End); outputFormatter.Space(); - outputFormatter.PrintToken(Tokens.Get); + outputFormatter.PrintToken(Tokens.Set); outputFormatter.NewLine(); return null; } @@ -1729,8 +1729,14 @@ namespace ICSharpCode.NRefactory.PrettyPrinter case BinaryOperatorType.LogicalOr: op = Tokens.OrElse; break; + case BinaryOperatorType.ReferenceEquality: + op = Tokens.Is; + break; + case BinaryOperatorType.ReferenceInequality: + op = Tokens.IsNot; + break; - case BinaryOperatorType.AS: + case BinaryOperatorType.AsCast: outputFormatter.PrintIdentifier("CType(Microsoft.VisualBasic.IIf(TypeOf "); nodeTracker.TrackedVisit(binaryOperatorExpression.Left, data); outputFormatter.PrintIdentifier(" Is "); @@ -1741,21 +1747,15 @@ namespace ICSharpCode.NRefactory.PrettyPrinter nodeTracker.TrackedVisit(binaryOperatorExpression.Right, data); outputFormatter.PrintIdentifier(")"); return null; - case BinaryOperatorType.IS: - outputFormatter.PrintToken(Tokens.TypeOf); - outputFormatter.Space(); + case BinaryOperatorType.TypeCheck: + outputFormatter.PrintIdentifier("TypeOf "); nodeTracker.TrackedVisit(binaryOperatorExpression.Left, data); - outputFormatter.Space(); - outputFormatter.PrintToken(Tokens.Is); - outputFormatter.Space(); + outputFormatter.PrintIdentifier(" Is "); nodeTracker.TrackedVisit(binaryOperatorExpression.Right, data); return null; case BinaryOperatorType.Equality: op = Tokens.Assign; - if (binaryOperatorExpression.Right is PrimitiveExpression && ((PrimitiveExpression)binaryOperatorExpression.Right).Value == null) { - op = Tokens.Is; - } break; case BinaryOperatorType.GreaterThan: op = Tokens.GreaterThan; diff --git a/src/Libraries/NRefactory/Project/Src/Parser/AST/General/Expressions/BinaryOperatorExpression.cs b/src/Libraries/NRefactory/Project/Src/Parser/AST/General/Expressions/BinaryOperatorExpression.cs index 8d5269b206..3c0ece8764 100644 --- a/src/Libraries/NRefactory/Project/Src/Parser/AST/General/Expressions/BinaryOperatorExpression.cs +++ b/src/Libraries/NRefactory/Project/Src/Parser/AST/General/Expressions/BinaryOperatorExpression.cs @@ -8,37 +8,61 @@ namespace ICSharpCode.NRefactory.Parser.AST { None, + /// '&' in C#, 'And' in VB. BitwiseAnd, + /// '|' in C#, 'Or' in VB. BitwiseOr, - LogicalAnd, // Lazy operator - LogicalOr, // Lazy operator + /// '&&' in C#, 'AndAlso' in VB. + LogicalAnd, + /// '||' in C#, 'OrElse' in VB. + LogicalOr, + /// '^' in C#, 'Xor' in VB. ExclusiveOr, + /// > GreaterThan, + /// >= GreaterThanOrEqual, + /// '==' in C#, '=' in VB. Equality, + /// '!=' in C#, '<>' in VB. InEquality, + /// < LessThan, + /// <= LessThanOrEqual, + /// + Add, + /// - Subtract, + /// * Multiply, + /// / Divide, + /// '%' in C#, 'Mod' in VB. Modulus, - ValueEquality, // What was this for ? - // VB specific operators + /// VB-only: \ DivideInteger, + /// VB-only: ^ Power, + /// VB-only: & Concat, - // additional + /// C#: << ShiftLeft, + /// C#: >> ShiftRight, - IS, - IsNot, - AS, - Like, // What was this for ? + /// VB-only: Is + ReferenceEquality, + /// VB-only: IsNot + ReferenceInequality, + /// C#: Is + TypeCheck, + /// C#: as-cast + AsCast, + /// VB-only: Like + Like, } public class BinaryOperatorExpression : Expression diff --git a/src/Libraries/NRefactory/Project/Src/Parser/AST/General/Statements/LocalVariableDeclaration.cs b/src/Libraries/NRefactory/Project/Src/Parser/AST/General/Statements/LocalVariableDeclaration.cs index 57d7c850dc..c115177473 100644 --- a/src/Libraries/NRefactory/Project/Src/Parser/AST/General/Statements/LocalVariableDeclaration.cs +++ b/src/Libraries/NRefactory/Project/Src/Parser/AST/General/Statements/LocalVariableDeclaration.cs @@ -3,6 +3,7 @@ using System; using System.Diagnostics; using System.Collections; +using System.Collections.Generic; namespace ICSharpCode.NRefactory.Parser.AST { @@ -10,8 +11,7 @@ namespace ICSharpCode.NRefactory.Parser.AST { TypeReference typeReference; Modifier modifier = Modifier.None; -// List variables = new List(1); - ArrayList variables = new ArrayList(1); + List variables = new List(1); BlockStatement block = BlockStatement.Null; // the block in witch the variable is declared; needed for the LookupTable public TypeReference TypeReference { @@ -32,7 +32,7 @@ namespace ICSharpCode.NRefactory.Parser.AST } } - public ArrayList Variables { + public List Variables { get { return variables; } diff --git a/src/Libraries/NRefactory/Project/Src/Parser/AST/General/TypeLevel/EventDeclaration.cs b/src/Libraries/NRefactory/Project/Src/Parser/AST/General/TypeLevel/EventDeclaration.cs index a15181a179..3a3111be76 100644 --- a/src/Libraries/NRefactory/Project/Src/Parser/AST/General/TypeLevel/EventDeclaration.cs +++ b/src/Libraries/NRefactory/Project/Src/Parser/AST/General/TypeLevel/EventDeclaration.cs @@ -19,6 +19,7 @@ using System; using System.Drawing; using System.Diagnostics; using System.Collections; +using System.Collections.Generic; using System.Collections.Specialized; namespace ICSharpCode.NRefactory.Parser.AST @@ -26,9 +27,8 @@ namespace ICSharpCode.NRefactory.Parser.AST public class EventDeclaration : ParametrizedNode { TypeReference typeReference = TypeReference.Null; -// List variableDeclarators = new List(1); + List variableDeclarators = new List(1); // ArrayList implementsClause = new ArrayList(); // VB only - ArrayList variableDeclarators = new ArrayList(1); ArrayList implementsClause = new ArrayList(); // VB only EventAddRegion addRegion = EventAddRegion.Null; // only for C# EventRemoveRegion removeRegion = EventRemoveRegion.Null; // only for C# @@ -43,12 +43,12 @@ namespace ICSharpCode.NRefactory.Parser.AST typeReference = TypeReference.CheckNull(value); } } - public ArrayList VariableDeclarators { + public List VariableDeclarators { get { return variableDeclarators; } set { - variableDeclarators = value == null ? new ArrayList(1) : value; + variableDeclarators = value == null ? new List(1) : value; } } @@ -110,7 +110,7 @@ namespace ICSharpCode.NRefactory.Parser.AST { } - public EventDeclaration(TypeReference typeReference, ArrayList variableDeclarators, Modifier modifier, ArrayList attributes) : base(modifier, attributes) + public EventDeclaration(TypeReference typeReference, List variableDeclarators, Modifier modifier, ArrayList attributes) : base(modifier, attributes) { this.TypeReference = typeReference; this.VariableDeclarators = variableDeclarators; diff --git a/src/Libraries/NRefactory/Project/Src/Parser/AST/General/TypeLevel/FieldDeclaration.cs b/src/Libraries/NRefactory/Project/Src/Parser/AST/General/TypeLevel/FieldDeclaration.cs index 0e6521590a..abbc213780 100644 --- a/src/Libraries/NRefactory/Project/Src/Parser/AST/General/TypeLevel/FieldDeclaration.cs +++ b/src/Libraries/NRefactory/Project/Src/Parser/AST/General/TypeLevel/FieldDeclaration.cs @@ -18,6 +18,7 @@ using System; using System.Diagnostics; using System.Collections; +using System.Collections.Generic; namespace ICSharpCode.NRefactory.Parser.AST { @@ -27,8 +28,7 @@ namespace ICSharpCode.NRefactory.Parser.AST ArrayList attributes; TypeReference typeReference = TypeReference.Null; Modifier modifier = Modifier.None; -// List fields = new List(1); // [VariableDeclaration] - ArrayList fields = new ArrayList(1); // [VariableDeclaration] + List fields = new List(1); public ArrayList Attributes { get { @@ -55,7 +55,7 @@ namespace ICSharpCode.NRefactory.Parser.AST modifier = value; } } - public ArrayList Fields { + public List Fields { get { return fields; } diff --git a/src/Libraries/NRefactory/Project/Src/Parser/AST/General/TypeLevel/PropertyGetSetRegion.cs b/src/Libraries/NRefactory/Project/Src/Parser/AST/General/TypeLevel/PropertyGetSetRegion.cs index e1d27d89ed..eed9b811c3 100644 --- a/src/Libraries/NRefactory/Project/Src/Parser/AST/General/TypeLevel/PropertyGetSetRegion.cs +++ b/src/Libraries/NRefactory/Project/Src/Parser/AST/General/TypeLevel/PropertyGetSetRegion.cs @@ -21,6 +21,9 @@ using System.Collections; namespace ICSharpCode.NRefactory.Parser.AST { + /// + /// Base class for PropertyGetRegion and PropertySetRegion. + /// public abstract class PropertyGetSetRegion : AttributedNode, INullable { BlockStatement block = BlockStatement.Null; // can be null if only the definition is there (interface declaration) diff --git a/src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs b/src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs index d265127174..5a99f03030 100644 --- a/src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs +++ b/src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs @@ -1798,7 +1798,7 @@ Modifiers m, ArrayList attributes) { Expression expr; ArrayList p = new ArrayList(); Statement stmt = null; - ArrayList variableDeclarators = new ArrayList(); + List variableDeclarators = new List(); List templates = new List(); if (la.kind == 58) { @@ -2664,7 +2664,7 @@ out Statement stmt) { void VariableDeclarator( #line 1462 "cs.ATG" -ArrayList fieldDeclaration) { +List fieldDeclaration) { #line 1463 "cs.ATG" Expression expr = null; @@ -5068,12 +5068,12 @@ ref expr); lexer.NextToken(); #line 2136 "cs.ATG" - op = BinaryOperatorType.IS; + op = BinaryOperatorType.TypeCheck; } else if (la.kind == 48) { lexer.NextToken(); #line 2137 "cs.ATG" - op = BinaryOperatorType.AS; + op = BinaryOperatorType.AsCast; } else SynErr(183); Type( #line 2139 "cs.ATG" diff --git a/src/Libraries/NRefactory/Project/Src/Parser/CSharp/cs.ATG b/src/Libraries/NRefactory/Project/Src/Parser/CSharp/cs.ATG index 005ce8f63d..b0f55328e9 100644 --- a/src/Libraries/NRefactory/Project/Src/Parser/CSharp/cs.ATG +++ b/src/Libraries/NRefactory/Project/Src/Parser/CSharp/cs.ATG @@ -1052,7 +1052,7 @@ StructMemberDecl Expression expr; ArrayList p = new ArrayList(); Statement stmt = null; - ArrayList variableDeclarators = new ArrayList(); + List variableDeclarators = new List(); List templates = new List(); .) = @@ -1459,7 +1459,7 @@ InterfaceAccessors +VariableDeclarator fieldDeclaration> (. Expression expr = null; .) = ident (. VariableDeclaration f = new VariableDeclaration(t.val); .) @@ -2133,8 +2133,8 @@ RelationalExpr UnaryExpr ShiftExpr (. outExpr = new BinaryOperatorExpression(outExpr, op, expr); .) | ( - "is" (. op = BinaryOperatorType.IS; .) - | "as" (. op = BinaryOperatorType.AS; .) + "is" (. op = BinaryOperatorType.TypeCheck; .) + | "as" (. op = BinaryOperatorType.AsCast; .) ) Type (. outExpr = new BinaryOperatorExpression(outExpr, op, new TypeReferenceExpression(type)); .) } diff --git a/src/Libraries/NRefactory/Project/Src/Parser/Frames/trace.txt b/src/Libraries/NRefactory/Project/Src/Parser/Frames/trace.txt index 374465f8f0..228e11811a 100644 --- a/src/Libraries/NRefactory/Project/Src/Parser/Frames/trace.txt +++ b/src/Libraries/NRefactory/Project/Src/Parser/Frames/trace.txt @@ -4,2221 +4,2221 @@ Graph nodes: val code ---------------------------------------------------- 0 eps 0 0 - 1 t EOL -2 426 + 1 t EOL -2 427 2 iter 4 0 1 0 - 3 nt OptionStmt -4 427 + 3 nt OptionStmt -4 428 4 iter 6 0 3 0 - 5 nt ImportsStmt -6 428 + 5 nt ImportsStmt -6 429 6 iter 9 0 5 0 - 7 rslv 8 429 - 8 nt GlobalAttrib -9 429 + 7 rslv 8 430 + 8 nt GlobalAttrib -9 430 9 iter 11 0 7 0 - 10 nt NamespaceMem -11 430 + 10 nt NamespaceMem -11 431 11 iter 12 0 10 0 - 12 t EOF 0 431 - 13 t "Option" 14 435 - 14 sem 23 6825 0 - 15 t "Explicit" 17 437 - 16 nt OptionValue -18 6889 437 + 12 t EOF 0 432 + 13 t "Option" 14 436 + 14 sem 23 6860 0 + 15 t "Explicit" 17 438 + 16 nt OptionValue -18 6924 438 17 opt 18 0 16 0 - 18 sem -33 6906 0 - 19 t "Strict" 21 440 - 20 nt OptionValue -22 6996 440 + 18 sem -33 6941 0 + 19 t "Strict" 21 441 + 20 nt OptionValue -22 7031 441 21 opt 22 0 20 0 - 22 sem -33 7013 0 - 23 alt 33 24 15 437 - 24 alt 0 32 19 440 - 25 t "Compare" 30 443 - 26 t "Binary" 27 443 - 27 sem -33 7102 0 - 28 t "Text" 29 444 - 29 sem -33 7185 0 - 30 alt -33 31 26 443 - 31 alt 0 0 28 444 - 32 alt 0 0 25 443 - 33 nt EndOfStmt 34 447 - 34 sem 0 7280 0 - 35 t "On" 36 457 - 36 sem 0 7437 0 - 37 t "Off" 38 459 - 38 sem 0 7468 0 - 39 alt 0 40 35 457 - 40 alt 0 0 37 459 - 41 t EOL 0 464 - 42 t ":" 44 466 - 43 t EOL 0 466 + 22 sem -33 7048 0 + 23 alt 33 24 15 438 + 24 alt 0 32 19 441 + 25 t "Compare" 30 444 + 26 t "Binary" 27 444 + 27 sem -33 7137 0 + 28 t "Text" 29 445 + 29 sem -33 7220 0 + 30 alt -33 31 26 444 + 31 alt 0 0 28 445 + 32 alt 0 0 25 444 + 33 nt EndOfStmt 34 448 + 34 sem 0 7315 0 + 35 t "On" 36 458 + 36 sem 0 7472 0 + 37 t "Off" 38 460 + 38 sem 0 7503 0 + 39 alt 0 40 35 458 + 40 alt 0 0 37 460 + 41 t EOL 0 465 + 42 t ":" 44 467 + 43 t EOL 0 467 44 opt 0 0 43 0 - 45 alt 0 46 41 464 - 46 alt 0 0 42 466 - 47 t "Imports" 48 472 - 48 sem 49 7619 0 - 49 nt ImportClause 50 7680 477 - 50 sem 54 7690 0 - 51 t "," 52 479 - 52 nt ImportClause 53 7732 479 - 53 sem -54 7742 0 + 45 alt 0 46 41 465 + 46 alt 0 0 42 467 + 47 t "Imports" 48 473 + 48 sem 49 7654 0 + 49 nt ImportClause 50 7715 478 + 50 sem 54 7725 0 + 51 t "," 52 480 + 52 nt ImportClause 53 7767 480 + 53 sem -54 7777 0 54 iter 55 0 51 0 - 55 nt EndOfStmt 56 481 - 56 sem 0 7784 0 - 57 rslv 58 496 - 58 nt Identifier 59 496 - 59 sem 60 8150 0 - 60 t "=" -62 496 + 55 nt EndOfStmt 56 482 + 56 sem 0 7819 0 + 57 rslv 58 497 + 58 nt Identifier 59 497 + 59 sem 60 8185 0 + 60 t "=" -62 497 61 opt 62 0 57 0 - 62 nt Qualident 63 8192 497 - 63 sem 0 8215 0 - 64 t "Namespace" 65 516 - 65 sem 66 8594 0 - 66 nt Qualident 67 8640 520 - 67 sem 68 8663 0 - 68 t EOL 69 527 - 69 nt NamespaceBod 70 528 - 70 sem 0 8855 0 - 71 nt AttributeSec 72 8947 534 - 72 sem -73 8963 0 + 62 nt Qualident 63 8227 498 + 63 sem 0 8250 0 + 64 t "Namespace" 65 517 + 65 sem 66 8629 0 + 66 nt Qualident 67 8675 521 + 67 sem 68 8698 0 + 68 t EOL 69 528 + 69 nt NamespaceBod 70 529 + 70 sem 0 8890 0 + 71 nt AttributeSec 72 8982 535 + 72 sem -73 8998 0 73 iter 75 0 71 0 - 74 nt TypeModifier -75 9010 535 + 74 nt TypeModifier -75 9045 536 75 iter 76 0 74 0 - 76 nt NonModuleDec 0 9036 535 - 77 alt 0 78 64 516 + 76 nt NonModuleDec 0 9071 536 + 77 alt 0 78 64 517 78 alt 0 0 73 0 - 79 sem 82 9242 0 - 80 t "Partial" 81 546 - 81 sem -83 9333 0 + 79 sem 82 9277 0 + 80 t "Partial" 81 547 + 81 sem -83 9368 0 82 opt 83 0 80 0 - 83 t "Class" 84 547 - 84 sem 85 9356 0 - 85 nt Identifier 86 555 - 86 sem 87 9644 0 - 87 nt EndOfStmt 90 556 - 88 nt ClassBaseTyp 89 9739 557 - 89 sem -93 9752 0 + 83 t "Class" 84 548 + 84 sem 85 9391 0 + 85 nt Identifier 86 556 + 86 sem 87 9679 0 + 87 nt EndOfStmt 90 557 + 88 nt ClassBaseTyp 89 9774 558 + 89 sem -93 9787 0 90 opt 93 0 88 0 - 91 nt TypeImplemen 92 9811 558 - 92 sem -93 9825 0 + 91 nt TypeImplemen 92 9846 559 + 92 sem -93 9860 0 93 iter 94 0 91 0 - 94 nt ClassBody 95 9877 559 - 95 sem 0 9894 0 - 96 t "Module" 97 563 - 97 sem 98 9950 0 - 98 nt Identifier 99 572 - 99 sem 100 10232 0 - 100 t EOL 101 573 - 101 nt ModuleBody 102 10317 574 - 102 sem 0 10334 0 + 94 nt ClassBody 95 9912 560 + 95 sem 0 9929 0 + 96 t "Module" 97 564 + 97 sem 98 9985 0 + 98 nt Identifier 99 573 + 99 sem 100 10267 0 + 100 t EOL 101 574 + 101 nt ModuleBody 102 10352 575 + 102 sem 0 10369 0 103 alt 0 104 79 0 - 104 alt 0 115 96 563 - 105 t "Structure" 106 579 - 106 sem 107 10430 0 - 107 nt Identifier 108 588 - 108 sem 109 10759 0 - 109 t EOL 112 589 - 110 nt TypeImplemen 111 10853 589 - 111 sem -112 10876 0 + 104 alt 0 115 96 564 + 105 t "Structure" 106 580 + 106 sem 107 10465 0 + 107 nt Identifier 108 589 + 108 sem 109 10794 0 + 109 t EOL 112 590 + 110 nt TypeImplemen 111 10888 590 + 111 sem -112 10911 0 112 iter 113 0 110 0 - 113 nt StructureBod 114 10940 590 - 114 sem 0 10957 0 - 115 alt 0 127 105 579 - 116 t "Enum" 117 596 - 117 sem 118 11060 0 - 118 nt Identifier 119 606 - 119 sem 123 11308 0 - 120 t "As" 121 607 - 121 nt PrimitiveTyp 122 11400 607 - 122 sem -124 11413 0 + 113 nt StructureBod 114 10975 591 + 114 sem 0 10992 0 + 115 alt 0 127 105 580 + 116 t "Enum" 117 597 + 117 sem 118 11095 0 + 118 nt Identifier 119 607 + 119 sem 123 11343 0 + 120 t "As" 121 608 + 121 nt PrimitiveTyp 122 11435 608 + 122 sem -124 11448 0 123 opt 124 0 120 0 - 124 t EOL 125 608 - 125 nt EnumBody 126 11464 609 - 126 sem 0 11481 0 - 127 alt 0 138 116 596 - 128 t "Interface" 129 615 - 129 sem 130 11589 0 - 130 nt Identifier 131 623 - 131 sem 132 11861 0 - 132 nt EndOfStmt 135 624 - 133 nt InterfaceBas 134 11954 624 - 134 sem -135 11977 0 + 124 t EOL 125 609 + 125 nt EnumBody 126 11499 610 + 126 sem 0 11516 0 + 127 alt 0 138 116 597 + 128 t "Interface" 129 616 + 129 sem 130 11624 0 + 130 nt Identifier 131 624 + 131 sem 132 11896 0 + 132 nt EndOfStmt 135 625 + 133 nt InterfaceBas 134 11989 625 + 134 sem -135 12012 0 135 iter 136 0 133 0 - 136 nt InterfaceBod 137 12052 625 - 137 sem 0 12069 0 - 138 alt 0 169 128 615 - 139 t "Delegate" 140 631 - 140 sem 164 12175 0 - 141 t "Sub" 142 640 - 142 nt Identifier 143 640 - 143 sem 149 12462 0 - 144 t "(" 146 641 - 145 nt FormalParame -147 12524 641 + 136 nt InterfaceBod 137 12087 626 + 137 sem 0 12104 0 + 138 alt 0 169 128 616 + 139 t "Delegate" 140 632 + 140 sem 164 12210 0 + 141 t "Sub" 142 641 + 142 nt Identifier 143 641 + 143 sem 149 12497 0 + 144 t "(" 146 642 + 145 nt FormalParame -147 12559 642 146 opt 147 0 145 0 - 147 t ")" 148 641 - 148 sem -166 12540 0 + 147 t ")" 148 642 + 148 sem -166 12575 0 149 opt -166 0 144 0 - 150 t "Function" 151 643 - 151 nt Identifier 152 643 - 152 sem 158 12608 0 - 153 t "(" 155 644 - 154 nt FormalParame -156 12670 644 + 150 t "Function" 151 644 + 151 nt Identifier 152 644 + 152 sem 158 12643 0 + 153 t "(" 155 645 + 154 nt FormalParame -156 12705 645 155 opt 156 0 154 0 - 156 t ")" 157 644 - 157 sem -163 12686 0 + 156 t ")" 157 645 + 157 sem -163 12721 0 158 opt 163 0 153 0 - 159 t "As" 160 645 - 160 sem 161 12734 0 - 161 nt TypeName 162 12766 645 - 162 sem -166 12779 0 + 159 t "As" 160 646 + 160 sem 161 12769 0 + 161 nt TypeName 162 12801 646 + 162 sem -166 12814 0 163 opt -166 0 159 0 - 164 alt 166 165 141 640 - 165 alt 0 0 150 643 - 166 sem 167 12827 0 - 167 t EOL 168 648 - 168 sem 0 12887 0 - 169 alt 0 0 139 631 - 170 nt NamespaceMem -171 655 + 164 alt 166 165 141 641 + 165 alt 0 0 150 644 + 166 sem 167 12862 0 + 167 t EOL 168 649 + 168 sem 0 12922 0 + 169 alt 0 0 139 632 + 170 nt NamespaceMem -171 656 171 iter 172 0 170 0 - 172 t "End" 173 656 - 173 t "Namespace" 174 656 - 174 t EOL 0 657 - 175 sem 178 13095 0 - 176 nt AttributeSec 177 13198 666 - 177 sem -178 13214 0 + 172 t "End" 173 657 + 173 t "Namespace" 174 657 + 174 t EOL 0 658 + 175 sem 178 13130 0 + 176 nt AttributeSec 177 13233 667 + 177 sem -178 13249 0 178 iter 180 0 176 0 - 179 nt MemberModifi -180 13264 667 + 179 nt MemberModifi -180 13299 668 180 iter 181 0 179 0 - 181 nt ClassMemberD -182 13288 668 + 181 nt ClassMemberD -182 13323 669 182 iter 183 0 175 0 - 183 t "End" 184 670 - 184 t "Class" 185 670 - 185 sem 186 13326 0 - 186 t EOL 0 671 - 187 sem 190 13463 0 - 188 nt AttributeSec 189 13566 680 - 189 sem -190 13582 0 + 183 t "End" 184 671 + 184 t "Class" 185 671 + 185 sem 186 13361 0 + 186 t EOL 0 672 + 187 sem 190 13498 0 + 188 nt AttributeSec 189 13601 681 + 189 sem -190 13617 0 190 iter 192 0 188 0 - 191 nt MemberModifi -192 13632 681 + 191 nt MemberModifi -192 13667 682 192 iter 193 0 191 0 - 193 nt StructureMem -194 13660 682 + 193 nt StructureMem -194 13695 683 194 iter 195 0 187 0 - 195 t "End" 196 684 - 196 t "Structure" 197 684 - 197 sem 198 13702 0 - 198 t EOL 0 685 - 199 sem 202 13849 0 - 200 nt AttributeSec 201 13952 695 - 201 sem -202 13968 0 + 195 t "End" 196 685 + 196 t "Structure" 197 685 + 197 sem 198 13737 0 + 198 t EOL 0 686 + 199 sem 202 13884 0 + 200 nt AttributeSec 201 13987 696 + 201 sem -202 14003 0 202 iter 204 0 200 0 - 203 nt MemberModifi -204 14018 696 + 203 nt MemberModifi -204 14053 697 204 iter 205 0 203 0 - 205 nt ClassMemberD -206 14042 697 + 205 nt ClassMemberD -206 14077 698 206 iter 207 0 199 0 - 207 t "End" 208 699 - 208 t "Module" 209 699 - 209 sem 210 14081 0 - 210 t EOL 0 700 - 211 nt EnumMemberDe 212 14220 706 - 212 sem -213 14230 0 + 207 t "End" 208 700 + 208 t "Module" 209 700 + 209 sem 210 14116 0 + 210 t EOL 0 701 + 211 nt EnumMemberDe 212 14255 707 + 212 sem -213 14265 0 213 iter 214 0 211 0 - 214 t "End" 215 708 - 215 t "Enum" 216 708 - 216 sem 217 14284 0 - 217 t EOL 0 709 - 218 nt InterfaceMem -219 713 + 214 t "End" 215 709 + 215 t "Enum" 216 709 + 216 sem 217 14319 0 + 217 t EOL 0 710 + 218 nt InterfaceMem -219 714 219 iter 220 0 218 0 - 220 t "End" 221 714 - 221 t "Interface" 222 714 - 222 sem 223 14427 0 - 223 t EOL 0 715 - 224 nt AttributeSec 225 14827 730 - 225 sem -226 14845 0 + 220 t "End" 221 715 + 221 t "Interface" 222 715 + 222 sem 223 14462 0 + 223 t EOL 0 716 + 224 nt AttributeSec 225 14862 731 + 225 sem -226 14880 0 226 iter 228 0 224 0 - 227 nt MemberModifi -228 15018 734 + 227 nt MemberModifi -228 15053 735 228 iter 254 0 227 0 - 229 t "Event" 230 736 - 230 sem 231 15046 0 - 231 nt Identifier 232 738 - 232 sem 237 15105 0 - 233 t "(" 235 739 - 234 nt FormalParame -236 15153 739 + 229 t "Event" 230 737 + 230 sem 231 15081 0 + 231 nt Identifier 232 739 + 232 sem 237 15140 0 + 233 t "(" 235 740 + 234 nt FormalParame -236 15188 740 235 opt 236 0 234 0 - 236 t ")" -240 739 + 236 t ")" -240 740 237 opt 240 0 233 0 - 238 t "As" 239 740 - 239 nt TypeName -241 15187 740 + 238 t "As" 239 741 + 239 nt TypeName -241 15222 741 240 opt 241 0 238 0 - 241 t EOL 242 741 - 242 sem 0 15216 0 - 243 t "Sub" 244 748 - 244 sem 245 15403 0 - 245 nt Identifier 246 750 - 246 sem 251 15463 0 - 247 t "(" 249 751 - 248 nt FormalParame -250 15511 751 + 241 t EOL 242 742 + 242 sem 0 15251 0 + 243 t "Sub" 244 749 + 244 sem 245 15438 0 + 245 nt Identifier 246 751 + 246 sem 251 15498 0 + 247 t "(" 249 752 + 248 nt FormalParame -250 15546 752 249 opt 250 0 248 0 - 250 t ")" -252 751 + 250 t ")" -252 752 251 opt 252 0 247 0 - 252 t EOL 253 752 - 253 sem 0 15543 0 - 254 alt 0 255 229 736 - 255 alt 0 272 243 748 - 256 t "Function" 257 760 - 257 sem 258 15792 0 - 258 nt Identifier 259 762 - 259 sem 264 15852 0 - 260 t "(" 262 763 - 261 nt FormalParame -263 15900 763 + 252 t EOL 253 753 + 253 sem 0 15578 0 + 254 alt 0 255 229 737 + 255 alt 0 272 243 749 + 256 t "Function" 257 761 + 257 sem 258 15827 0 + 258 nt Identifier 259 763 + 259 sem 264 15887 0 + 260 t "(" 262 764 + 261 nt FormalParame -263 15935 764 262 opt 263 0 261 0 - 263 t ")" -269 763 + 263 t ")" -269 764 264 opt 269 0 260 0 - 265 t "As" 267 764 - 266 nt AttributeSec -267 15944 764 + 265 t "As" 267 765 + 266 nt AttributeSec -267 15979 765 267 iter 268 0 266 0 - 268 nt TypeName -270 15987 764 + 268 nt TypeName -270 16022 765 269 opt 270 0 265 0 - 270 sem 271 16009 0 - 271 t EOL 0 774 - 272 alt 0 288 256 760 - 273 t "Property" 274 776 - 274 sem 275 16345 0 - 275 nt Identifier 276 778 - 276 sem 281 16408 0 - 277 t "(" 279 779 - 278 nt FormalParame -280 16457 779 + 270 sem 271 16044 0 + 271 t EOL 0 775 + 272 alt 0 288 256 761 + 273 t "Property" 274 777 + 274 sem 275 16380 0 + 275 nt Identifier 276 779 + 276 sem 281 16443 0 + 277 t "(" 279 780 + 278 nt FormalParame -280 16492 780 279 opt 280 0 278 0 - 280 t ")" -284 779 + 280 t ")" -284 780 281 opt 284 0 277 0 - 282 t "As" 283 780 - 283 nt TypeName -285 16491 780 + 282 t "As" 283 781 + 283 nt TypeName -285 16526 781 284 opt 285 0 282 0 - 285 sem 286 16513 0 - 286 t EOL 287 786 - 287 sem 0 16609 0 - 288 alt 0 0 273 776 - 289 nt NonModuleDec 0 16857 795 + 285 sem 286 16548 0 + 286 t EOL 287 787 + 287 sem 0 16644 0 + 288 alt 0 0 273 777 + 289 nt NonModuleDec 0 16892 796 290 alt 0 291 226 0 - 291 alt 0 0 289 795 - 292 nt AttributeSec 293 17107 805 - 293 sem -294 17123 0 + 291 alt 0 0 289 796 + 292 nt AttributeSec 293 17142 806 + 293 sem -294 17158 0 294 iter 295 0 292 0 - 295 nt Identifier 296 806 - 296 sem 300 17174 0 - 297 t "=" 298 813 - 298 nt Expr 299 17334 813 - 299 sem -301 17347 0 + 295 nt Identifier 296 807 + 296 sem 300 17209 0 + 297 t "=" 298 814 + 298 nt Expr 299 17369 814 + 299 sem -301 17382 0 300 opt 301 0 297 0 - 301 t EOL 0 814 - 302 nt StructureMem 0 17467 818 - 303 t "Inherits" 304 826 - 304 nt TypeName 305 17603 827 - 305 sem 306 17616 0 - 306 nt EndOfStmt 0 828 - 307 nt NonModuleDec 0 17883 837 - 308 t "Sub" 309 839 - 309 sem 351 17930 0 - 310 sem 311 17978 0 - 311 nt Identifier 312 848 - 312 sem 317 18144 0 - 313 t "(" 315 853 - 314 nt FormalParame -316 18228 853 + 301 t EOL 0 815 + 302 nt StructureMem 0 17502 819 + 303 t "Inherits" 304 827 + 304 nt TypeName 305 17638 828 + 305 sem 306 17651 0 + 306 nt EndOfStmt 0 829 + 307 nt NonModuleDec 0 17950 838 + 308 t "Sub" 309 840 + 309 sem 351 17997 0 + 310 sem 311 18045 0 + 311 nt Identifier 312 849 + 312 sem 317 18211 0 + 313 t "(" 315 854 + 314 nt FormalParame -316 18295 854 315 opt 316 0 314 0 - 316 t ")" -322 853 + 316 t ")" -322 854 317 opt 322 0 313 0 - 318 nt ImplementsCl -323 18276 856 - 319 nt HandlesClaus -323 18324 858 - 320 alt -323 321 318 856 - 321 alt 0 0 319 858 + 318 nt ImplementsCl -323 18343 857 + 319 nt HandlesClaus -323 18391 859 + 320 alt -323 321 318 857 + 321 alt 0 0 319 859 322 opt 323 0 320 0 - 323 sem 324 18360 0 - 324 t EOL 334 862 - 325 rslv 326 865 - 326 sem 0 18490 0 - 327 sem 328 18950 0 - 328 nt Block 329 19456 890 - 329 sem 330 19478 0 - 330 t "End" 331 895 - 331 t "Sub" 332 895 - 332 sem 333 19585 0 - 333 t EOL 0 895 - 334 alt 0 335 325 865 + 323 sem 324 18427 0 + 324 t EOL 334 863 + 325 rslv 326 866 + 326 sem 0 18557 0 + 327 sem 328 19017 0 + 328 nt Block 329 19523 891 + 329 sem 330 19545 0 + 330 t "End" 331 896 + 331 t "Sub" 332 896 + 332 sem 333 19652 0 + 333 t EOL 0 896 + 334 alt 0 335 325 866 335 alt 0 0 327 0 - 336 t "New" 341 898 - 337 t "(" 339 898 - 338 nt FormalParame -340 19702 898 + 336 t "New" 341 899 + 337 t "(" 339 899 + 338 nt FormalParame -340 19769 899 339 opt 340 0 338 0 - 340 t ")" -342 898 + 340 t ")" -342 899 341 opt 342 0 337 0 - 342 sem 343 19723 0 - 343 sem 344 19764 0 - 344 t EOL 345 901 - 345 nt Block 346 19829 902 - 346 t "End" 347 903 - 347 t "Sub" 348 903 - 348 sem 349 19857 0 - 349 t EOL 350 903 - 350 sem 0 19909 0 + 342 sem 343 19790 0 + 343 sem 344 19831 0 + 344 t EOL 345 902 + 345 nt Block 346 19896 903 + 346 t "End" 347 904 + 347 t "Sub" 348 904 + 348 sem 349 19924 0 + 349 t EOL 350 904 + 350 sem 0 19976 0 351 alt 0 352 310 0 - 352 alt 0 0 336 898 - 353 alt 0 354 307 837 - 354 alt 0 387 308 839 - 355 t "Function" 356 915 - 356 sem 357 20240 0 - 357 nt Identifier 358 923 - 358 sem 363 20515 0 - 359 t "(" 361 924 - 360 nt FormalParame -362 20562 924 + 352 alt 0 0 336 899 + 353 alt 0 354 307 838 + 354 alt 0 387 308 840 + 355 t "Function" 356 916 + 356 sem 357 20307 0 + 357 nt Identifier 358 924 + 358 sem 363 20582 0 + 359 t "(" 361 925 + 360 nt FormalParame -362 20629 925 361 opt 362 0 360 0 - 362 t ")" -368 924 + 362 t ")" -368 925 363 opt 368 0 359 0 - 364 t "As" 366 925 - 365 nt AttributeSec -366 20605 925 + 364 t "As" 366 926 + 365 nt AttributeSec -366 20672 926 366 iter 367 0 365 0 - 367 nt TypeName -369 20648 925 + 367 nt TypeName -369 20715 926 368 opt 369 0 364 0 - 369 sem 374 20668 0 - 370 nt ImplementsCl -375 20774 933 - 371 nt HandlesClaus -375 20820 935 - 372 alt -375 373 370 933 - 373 alt 0 0 371 935 + 369 sem 374 20735 0 + 370 nt ImplementsCl -375 20841 934 + 371 nt HandlesClaus -375 20887 936 + 372 alt -375 373 370 934 + 373 alt 0 0 371 936 374 opt 375 0 372 0 - 375 t EOL 385 938 - 376 rslv 377 941 - 377 sem 0 20936 0 - 378 sem 379 21390 0 - 379 nt Block 380 21901 964 - 380 sem 381 21923 0 - 381 t "End" 382 969 - 382 t "Function" 383 969 - 383 sem 384 22045 0 - 384 t EOL 0 974 - 385 alt 0 386 376 941 + 375 t EOL 385 939 + 376 rslv 377 942 + 377 sem 0 21003 0 + 378 sem 379 21457 0 + 379 nt Block 380 21968 965 + 380 sem 381 21990 0 + 381 t "End" 382 970 + 382 t "Function" 383 970 + 383 sem 384 22112 0 + 384 t EOL 0 975 + 385 alt 0 386 376 942 386 alt 0 0 378 0 - 387 alt 0 431 355 915 - 388 t "Declare" 389 978 - 389 sem 391 22232 0 - 390 nt Charset -429 22464 987 + 387 alt 0 431 355 916 + 388 t "Declare" 389 979 + 389 sem 391 22299 0 + 390 nt Charset -429 22531 988 391 opt 429 0 390 0 - 392 t "Sub" 393 989 - 393 nt Identifier 394 990 - 394 sem 395 22521 0 - 395 t "Lib" 396 991 - 396 t LiteralStrin 397 991 - 397 sem 401 22566 0 - 398 t "Alias" 399 992 - 399 t LiteralStrin 400 992 - 400 sem -406 22627 0 + 392 t "Sub" 393 990 + 393 nt Identifier 394 991 + 394 sem 395 22588 0 + 395 t "Lib" 396 992 + 396 t LiteralStrin 397 992 + 397 sem 401 22633 0 + 398 t "Alias" 399 993 + 399 t LiteralStrin 400 993 + 400 sem -406 22694 0 401 opt 406 0 398 0 - 402 t "(" 404 993 - 403 nt FormalParame -405 22689 993 + 402 t "(" 404 994 + 403 nt FormalParame -405 22756 994 404 opt 405 0 403 0 - 405 t ")" -407 993 + 405 t ")" -407 994 406 opt 407 0 402 0 - 407 t EOL 408 994 - 408 sem 0 22724 0 - 409 t "Function" 410 1002 - 410 nt Identifier 411 1003 - 411 sem 412 23065 0 - 412 t "Lib" 413 1004 - 413 t LiteralStrin 414 1004 - 414 sem 418 23110 0 - 415 t "Alias" 416 1005 - 416 t LiteralStrin 417 1005 - 417 sem -423 23160 0 + 407 t EOL 408 995 + 408 sem 0 22791 0 + 409 t "Function" 410 1003 + 410 nt Identifier 411 1004 + 411 sem 412 23132 0 + 412 t "Lib" 413 1005 + 413 t LiteralStrin 414 1005 + 414 sem 418 23177 0 + 415 t "Alias" 416 1006 + 416 t LiteralStrin 417 1006 + 417 sem -423 23227 0 418 opt 423 0 415 0 - 419 t "(" 421 1006 - 420 nt FormalParame -422 23211 1006 + 419 t "(" 421 1007 + 420 nt FormalParame -422 23278 1007 421 opt 422 0 420 0 - 422 t ")" -426 1006 + 422 t ")" -426 1007 423 opt 426 0 419 0 - 424 t "As" 425 1007 - 425 nt TypeName -427 23245 1007 + 424 t "As" 425 1008 + 425 nt TypeName -427 23312 1008 426 opt 427 0 424 0 - 427 t EOL 428 1008 - 428 sem 0 23277 0 - 429 alt 0 430 392 989 - 430 alt 0 0 409 1002 - 431 alt 0 449 388 978 - 432 t "Event" 433 1018 - 433 sem 434 23615 0 - 434 nt Identifier 435 1025 - 435 sem 443 23799 0 - 436 t "As" 437 1027 - 437 nt TypeName -446 23836 1027 - 438 t "(" 440 1029 - 439 nt FormalParame -441 23882 1029 + 427 t EOL 428 1009 + 428 sem 0 23344 0 + 429 alt 0 430 392 990 + 430 alt 0 0 409 1003 + 431 alt 0 449 388 979 + 432 t "Event" 433 1019 + 433 sem 434 23682 0 + 434 nt Identifier 435 1026 + 435 sem 443 23866 0 + 436 t "As" 437 1028 + 437 nt TypeName -446 23903 1028 + 438 t "(" 440 1030 + 439 nt FormalParame -441 23949 1030 440 opt 441 0 439 0 - 441 t ")" -446 1029 + 441 t ")" -446 1030 442 opt -446 0 438 0 - 443 alt 446 444 436 1027 + 443 alt 446 444 436 1028 444 alt 0 0 442 0 - 445 nt ImplementsCl -447 23922 1031 + 445 nt ImplementsCl -447 23989 1032 446 opt 447 0 445 0 - 447 sem 448 23954 0 - 448 t EOL 0 1038 - 449 alt 0 458 432 1018 - 450 sem 451 24224 0 - 451 sem 452 24264 0 - 452 nt VariableDecl 455 24426 1046 - 453 t "," 454 1047 - 454 nt VariableDecl -455 24474 1047 + 447 sem 448 24021 0 + 448 t EOL 0 1039 + 449 alt 0 458 432 1019 + 450 sem 451 24291 0 + 451 sem 452 24331 0 + 452 nt VariableDecl 455 24493 1047 + 453 t "," 454 1048 + 454 nt VariableDecl -455 24541 1048 455 iter 456 0 453 0 - 456 t EOL 457 1048 - 457 sem 0 24511 0 + 456 t EOL 457 1049 + 457 sem 0 24578 0 458 alt 0 470 450 0 - 459 sem 460 24636 0 - 460 t "Const" 461 1056 - 461 sem 462 24679 0 - 462 sem 463 24714 0 - 463 nt ConstantDecl 466 24896 1061 - 464 t "," 465 1062 - 465 nt ConstantDecl -466 24944 1062 + 459 sem 460 24703 0 + 460 t "Const" 461 1057 + 461 sem 462 24746 0 + 462 sem 463 24781 0 + 463 nt ConstantDecl 466 24995 1062 + 464 t "," 465 1063 + 465 nt ConstantDecl -466 25043 1063 466 iter 467 0 464 0 - 467 sem 468 24975 0 - 468 t EOL 469 1067 - 469 sem 0 25059 0 + 467 sem 468 25074 0 + 468 t EOL 469 1068 + 469 sem 0 25158 0 470 alt 0 497 459 0 - 471 t "Property" 472 1073 - 472 sem 473 25164 0 - 473 nt Identifier 474 1078 - 474 sem 479 25283 0 - 475 t "(" 477 1079 - 476 nt FormalParame -478 25345 1079 + 471 t "Property" 472 1074 + 472 sem 473 25263 0 + 473 nt Identifier 474 1079 + 474 sem 479 25382 0 + 475 t "(" 477 1080 + 476 nt FormalParame -478 25444 1080 477 opt 478 0 476 0 - 478 t ")" -482 1079 + 478 t ")" -482 1080 479 opt 482 0 475 0 - 480 t "As" 481 1080 - 481 nt TypeName -483 25378 1080 + 480 t "As" 481 1081 + 481 nt TypeName -483 25477 1081 482 opt 483 0 480 0 - 483 sem 485 25398 0 - 484 nt ImplementsCl -486 25495 1086 + 483 sem 485 25497 0 + 484 nt ImplementsCl -486 25594 1087 485 opt 486 0 484 0 - 486 t EOL 495 1087 - 487 rslv 488 1090 - 488 sem 0 25606 0 - 489 sem 490 25939 0 - 490 nt AccessorDecl 491 26340 1112 - 491 t "End" 492 1113 - 492 t "Property" 493 1113 - 493 t EOL 494 1114 - 494 sem 0 26408 0 - 495 alt 0 496 487 1090 + 486 t EOL 495 1088 + 487 rslv 488 1091 + 488 sem 0 25705 0 + 489 sem 490 26038 0 + 490 nt AccessorDecl 491 26439 1113 + 491 t "End" 492 1114 + 492 t "Property" 493 1114 + 493 t EOL 494 1115 + 494 sem 0 26507 0 + 495 alt 0 496 487 1091 496 alt 0 0 489 0 - 497 alt 0 0 471 1073 - 498 nt AttributeSec 499 26791 1131 - 499 sem -500 26807 0 + 497 alt 0 0 471 1074 + 498 nt AttributeSec 499 26890 1132 + 499 sem -500 26906 0 500 iter 515 0 498 0 - 501 nt GetAccessorD 507 26860 1133 - 502 sem 505 26898 0 - 503 nt AttributeSec 504 26954 1136 - 504 sem -505 26970 0 + 501 nt GetAccessorD 507 26959 1134 + 502 sem 505 26997 0 + 503 nt AttributeSec 504 27053 1137 + 504 sem -505 27069 0 505 iter 506 0 503 0 - 506 nt SetAccessorD 0 27020 1137 + 506 nt SetAccessorD 0 27119 1138 507 opt 0 0 502 0 - 508 nt SetAccessorD 514 27075 1140 - 509 sem 512 27113 0 - 510 nt AttributeSec 511 27169 1143 - 511 sem -512 27185 0 + 508 nt SetAccessorD 514 27174 1141 + 509 sem 512 27212 0 + 510 nt AttributeSec 511 27268 1144 + 511 sem -512 27284 0 512 iter 513 0 510 0 - 513 nt GetAccessorD 0 27235 1144 + 513 nt GetAccessorD 0 27334 1145 514 opt 0 0 509 0 - 515 alt 0 516 501 1133 - 516 alt 0 0 508 1140 - 517 t "Get" 518 1152 - 518 t EOL 519 1153 - 519 nt Block 520 27414 1154 - 520 sem 521 27432 0 - 521 t "End" 522 1158 - 522 t "Get" 523 1158 - 523 t EOL 0 1159 - 524 t "Set" 529 1167 - 525 t "(" 527 1168 - 526 nt FormalParame -528 27709 1168 + 515 alt 0 516 501 1134 + 516 alt 0 0 508 1141 + 517 t "Get" 518 1153 + 518 t EOL 519 1154 + 519 nt Block 520 27513 1155 + 520 sem 521 27531 0 + 521 t "End" 522 1159 + 522 t "Get" 523 1159 + 523 t EOL 0 1160 + 524 t "Set" 529 1168 + 525 t "(" 527 1169 + 526 nt FormalParame -528 27808 1169 527 opt 528 0 526 0 - 528 t ")" -530 1168 + 528 t ")" -530 1169 529 opt 530 0 525 0 - 530 t EOL 531 1169 - 531 nt Block 532 27738 1170 - 532 sem 533 27756 0 - 533 t "End" 534 1175 - 534 t "Set" 535 1175 - 535 t EOL 0 1176 - 536 nt Identifier 537 1186 - 537 sem 540 28064 0 - 538 t "As" 539 1187 - 539 nt TypeName -541 28098 1187 + 530 t EOL 531 1170 + 531 nt Block 532 27837 1171 + 532 sem 533 27855 0 + 533 t "End" 534 1176 + 534 t "Set" 535 1176 + 535 t EOL 0 1177 + 536 nt Identifier 537 1187 + 537 sem 540 28179 0 + 538 t "As" 539 1188 + 539 nt TypeName -541 28213 1188 540 opt 541 0 538 0 - 541 t "=" 542 1188 - 542 nt Expr 543 28121 1188 - 543 sem 0 28139 0 - 544 nt Identifier 545 1202 - 545 sem 548 28462 0 - 546 rslv 547 1203 - 547 nt ArrayNameMod -551 28521 1203 + 541 t "=" 542 1189 + 542 nt Expr 543 28236 1189 + 543 sem 0 28254 0 + 544 nt Identifier 545 1203 + 545 sem 548 28593 0 + 546 rslv 547 1204 + 547 nt ArrayNameMod -551 28652 1204 548 opt 551 0 546 0 - 549 rslv 550 1204 - 550 nt ArrayInitial -563 28578 1204 + 549 rslv 550 1205 + 550 nt ArrayInitial -563 28709 1205 551 opt 563 0 549 0 - 552 rslv 553 1206 - 553 t "As" 554 1206 - 554 nt ObjectCreate 555 28655 1206 - 555 sem -565 28677 0 - 556 t "As" 557 1215 - 557 nt TypeName -559 28879 1215 + 552 rslv 553 1207 + 553 t "As" 554 1207 + 554 nt ObjectCreate 555 28786 1207 + 555 sem -565 28808 0 + 556 t "As" 557 1216 + 557 nt TypeName -559 29010 1216 558 opt 559 0 556 0 - 559 sem 562 28903 0 - 560 t "=" 561 1225 - 561 nt VariableInit -565 29157 1225 + 559 sem 562 29034 0 + 560 t "=" 561 1226 + 561 nt VariableInit -565 29288 1226 562 opt -565 0 560 0 - 563 alt 565 564 552 1206 + 563 alt 565 564 552 1207 564 alt 0 0 558 0 - 565 sem 0 29178 0 - 566 t "(" 567 1235 - 567 nt Initializati 568 29389 1235 - 568 t ")" 0 1235 - 569 nt Expr 570 29540 1244 - 570 sem 574 29553 0 - 571 t "," 572 1246 - 572 nt Expr 573 29634 1246 - 573 sem -574 29648 0 + 565 sem 0 29309 0 + 566 t "(" 567 1236 + 567 nt Initializati 568 29520 1236 + 568 t ")" 0 1236 + 569 nt Expr 570 29671 1245 + 570 sem 574 29684 0 + 571 t "," 572 1247 + 572 nt Expr 573 29765 1247 + 573 sem -574 29779 0 574 iter 0 0 571 0 - 575 nt Expr 0 29823 1255 - 576 nt ArrayInitial 0 29871 1256 - 577 alt 0 578 575 1255 - 578 alt 0 0 576 1256 - 579 t "{" 587 1265 - 580 nt VariableInit 581 30111 1267 - 581 sem 586 30131 0 - 582 rslv 583 1272 - 583 t "," 584 1272 - 584 nt VariableInit 585 30254 1272 - 585 sem -586 30271 0 + 575 nt Expr 0 29954 1256 + 576 nt ArrayInitial 0 30002 1257 + 577 alt 0 578 575 1256 + 578 alt 0 0 576 1257 + 579 t "{" 587 1266 + 580 nt VariableInit 581 30242 1268 + 581 sem 586 30262 0 + 582 rslv 583 1273 + 583 t "," 584 1273 + 584 nt VariableInit 585 30385 1273 + 585 sem -586 30402 0 586 iter -588 0 582 0 587 opt 588 0 580 0 - 588 t "}" 589 1276 - 589 sem 0 30355 0 + 588 t "}" 589 1277 + 589 sem 0 30486 0 590 eps 0 0 - 591 t "Ansi" 592 1281 - 592 sem 0 30498 0 + 591 t "Ansi" 592 1282 + 592 sem 0 30629 0 593 alt 0 594 590 0 - 594 alt 0 597 591 1281 - 595 t "Auto" 596 1282 - 596 sem 0 30556 0 - 597 alt 0 600 595 1282 - 598 t "Unicode" 599 1283 - 599 sem 0 30617 0 - 600 alt 0 0 598 1283 - 601 t "Handles" 602 1292 - 602 nt EventMemberS 603 30823 1292 - 603 sem 607 30836 0 - 604 t "," 605 1293 - 605 nt EventMemberS 606 30893 1293 - 606 sem -607 30907 0 + 594 alt 0 597 591 1282 + 595 t "Auto" 596 1283 + 596 sem 0 30687 0 + 597 alt 0 600 595 1283 + 598 t "Unicode" 599 1284 + 599 sem 0 30748 0 + 600 alt 0 0 598 1284 + 601 t "Handles" 602 1293 + 602 nt EventMemberS 603 30954 1293 + 603 sem 607 30967 0 + 604 t "," 605 1294 + 605 nt EventMemberS 606 31024 1294 + 606 sem -607 31038 0 607 iter 0 0 604 0 - 608 t "Inherits" 609 1302 - 609 nt TypeName 610 31079 1303 - 610 sem 614 31092 0 - 611 t "," 612 1305 - 612 nt TypeName 613 31140 1306 - 613 sem -614 31153 0 + 608 t "Inherits" 609 1303 + 609 nt TypeName 610 31210 1304 + 610 sem 614 31223 0 + 611 t "," 612 1306 + 612 nt TypeName 613 31271 1307 + 613 sem -614 31284 0 614 iter 615 0 611 0 - 615 t EOL 0 1308 - 616 t "Implements" 617 1317 - 617 nt TypeName 618 31360 1317 - 618 sem 622 31378 0 - 619 t "," 620 1322 - 620 nt TypeName 621 31434 1322 - 621 sem -622 31450 0 + 615 t EOL 0 1309 + 616 t "Implements" 617 1318 + 617 nt TypeName 618 31491 1318 + 618 sem 622 31509 0 + 619 t "," 620 1323 + 620 nt TypeName 621 31565 1323 + 621 sem -622 31581 0 622 iter 623 0 619 0 - 623 nt EndOfStmt 0 1325 - 624 t "Implements" 625 1335 - 625 nt Identifier 626 1335 - 626 sem 627 31695 0 - 627 t "." 628 1335 - 628 nt Qualident 629 31727 1335 - 629 sem 636 31744 0 - 630 t "," 631 1336 - 631 nt Identifier 632 1336 - 632 sem 633 31813 0 - 633 t "." 634 1336 - 634 nt Qualident 635 31845 1336 - 635 sem -636 31862 0 + 623 nt EndOfStmt 0 1326 + 624 t "Implements" 625 1336 + 625 nt Identifier 626 1336 + 626 sem 627 31826 0 + 627 t "." 628 1336 + 628 nt Qualident 629 31858 1336 + 629 sem 636 31875 0 + 630 t "," 631 1337 + 631 nt Identifier 632 1337 + 632 sem 633 31944 0 + 633 t "." 634 1337 + 634 nt Qualident 635 31976 1337 + 635 sem -636 31993 0 636 iter 0 0 630 0 - 637 nt Identifier 638 1341 - 638 sem 639 32017 0 - 639 t "." 640 1342 - 640 nt Identifier 641 1343 - 641 sem 0 32056 0 - 642 t "MyBase" 643 1344 - 643 t "." 648 1344 - 644 nt Identifier 645 1346 - 645 sem 0 32124 0 - 646 t "Error" 647 1347 - 647 sem 0 32170 0 - 648 alt 0 649 644 1346 - 649 alt 0 0 646 1347 - 650 alt 0 651 637 1341 - 651 alt 0 0 642 1344 - 652 nt ConditionalO 0 32256 1353 - 653 t "+" 654 1366 - 654 sem -662 32587 0 - 655 t "-" 656 1367 - 656 sem -662 32648 0 - 657 alt -662 658 653 1366 - 658 alt 0 661 655 1367 - 659 t "*" 660 1369 - 660 sem -662 32776 0 - 661 alt 0 0 659 1369 + 637 nt Identifier 638 1342 + 638 sem 639 32148 0 + 639 t "." 640 1343 + 640 nt Identifier 641 1344 + 641 sem 0 32187 0 + 642 t "MyBase" 643 1345 + 643 t "." 648 1345 + 644 nt Identifier 645 1347 + 645 sem 0 32255 0 + 646 t "Error" 647 1348 + 647 sem 0 32301 0 + 648 alt 0 649 644 1347 + 649 alt 0 0 646 1348 + 650 alt 0 651 637 1342 + 651 alt 0 0 642 1345 + 652 nt ConditionalO 0 32387 1354 + 653 t "+" 654 1367 + 654 sem -662 32718 0 + 655 t "-" 656 1368 + 656 sem -662 32779 0 + 657 alt -662 658 653 1367 + 658 alt 0 661 655 1368 + 659 t "*" 660 1370 + 660 sem -662 32907 0 + 661 alt 0 0 659 1370 662 iter 663 0 657 0 - 663 nt SimpleExpr 664 32840 1371 - 664 sem 0 32860 0 - 665 t "=" 666 1383 - 666 sem 0 33081 0 - 667 t "&=" 668 1384 - 668 sem 0 33132 0 - 669 alt 0 670 665 1383 - 670 alt 0 673 667 1384 - 671 t "+=" 672 1385 - 672 sem 0 33189 0 - 673 alt 0 676 671 1385 - 674 t "-=" 675 1386 - 675 sem 0 33237 0 - 676 alt 0 679 674 1386 - 677 t "*=" 678 1387 - 678 sem 0 33290 0 - 679 alt 0 682 677 1387 - 680 t "/=" 681 1388 - 681 sem 0 33343 0 - 682 alt 0 685 680 1388 - 683 t "\\=" 684 1389 - 684 sem 0 33395 0 - 685 alt 0 688 683 1389 - 686 t "^=" 687 1390 - 687 sem 0 33453 0 - 688 alt 0 691 686 1390 - 689 t "<<=" 690 1391 - 690 sem 0 33504 0 - 691 alt 0 694 689 1391 - 692 t ">>=" 693 1392 - 693 sem 0 33559 0 - 694 alt 0 0 692 1392 - 695 t LiteralStrin 696 1406 - 696 sem -807 33817 0 - 697 t LiteralChara 698 1407 - 698 sem -807 33907 0 - 699 alt 807 700 695 1406 - 700 alt 0 703 697 1407 - 701 t LiteralSingl 702 1408 - 702 sem -807 33995 0 - 703 alt 0 706 701 1408 - 704 t LiteralDoubl 705 1409 - 705 sem -807 34083 0 - 706 alt 0 709 704 1409 - 707 t LiteralInteg 708 1410 - 708 sem -807 34171 0 - 709 alt 0 712 707 1410 - 710 t LiteralDate 711 1411 - 711 sem -807 34257 0 - 712 alt 0 715 710 1411 - 713 t LiteralDecim 714 1412 - 714 sem -807 34345 0 - 715 alt 0 718 713 1412 - 716 t "True" 717 1414 - 717 sem -807 34500 0 - 718 alt 0 721 716 1414 - 719 t "False" 720 1415 - 720 sem -807 34577 0 - 721 alt 0 724 719 1415 - 722 t "Nothing" 723 1416 - 723 sem -807 34657 0 - 724 alt 0 729 722 1416 - 725 t "(" 726 1417 - 726 nt Expr 727 34736 1417 - 727 t ")" 728 1417 - 728 sem -807 34757 0 - 729 alt 0 732 725 1417 - 730 nt Identifier 731 1418 - 731 sem -807 34840 0 - 732 alt 0 738 730 1418 - 733 sem 734 34893 0 - 734 nt PrimitiveTyp 735 34941 1419 - 735 t "." 736 1420 - 736 nt Identifier 737 1420 - 737 sem -807 34972 0 + 663 nt SimpleExpr 664 32971 1372 + 664 sem 0 32991 0 + 665 t "=" 666 1384 + 666 sem 0 33212 0 + 667 t "&=" 668 1385 + 668 sem 0 33263 0 + 669 alt 0 670 665 1384 + 670 alt 0 673 667 1385 + 671 t "+=" 672 1386 + 672 sem 0 33320 0 + 673 alt 0 676 671 1386 + 674 t "-=" 675 1387 + 675 sem 0 33368 0 + 676 alt 0 679 674 1387 + 677 t "*=" 678 1388 + 678 sem 0 33421 0 + 679 alt 0 682 677 1388 + 680 t "/=" 681 1389 + 681 sem 0 33474 0 + 682 alt 0 685 680 1389 + 683 t "\\=" 684 1390 + 684 sem 0 33526 0 + 685 alt 0 688 683 1390 + 686 t "^=" 687 1391 + 687 sem 0 33584 0 + 688 alt 0 691 686 1391 + 689 t "<<=" 690 1392 + 690 sem 0 33635 0 + 691 alt 0 694 689 1392 + 692 t ">>=" 693 1393 + 693 sem 0 33690 0 + 694 alt 0 0 692 1393 + 695 t LiteralStrin 696 1407 + 696 sem -807 33948 0 + 697 t LiteralChara 698 1408 + 698 sem -807 34038 0 + 699 alt 807 700 695 1407 + 700 alt 0 703 697 1408 + 701 t LiteralSingl 702 1409 + 702 sem -807 34126 0 + 703 alt 0 706 701 1409 + 704 t LiteralDoubl 705 1410 + 705 sem -807 34214 0 + 706 alt 0 709 704 1410 + 707 t LiteralInteg 708 1411 + 708 sem -807 34302 0 + 709 alt 0 712 707 1411 + 710 t LiteralDate 711 1412 + 711 sem -807 34388 0 + 712 alt 0 715 710 1412 + 713 t LiteralDecim 714 1413 + 714 sem -807 34476 0 + 715 alt 0 718 713 1413 + 716 t "True" 717 1415 + 717 sem -807 34631 0 + 718 alt 0 721 716 1415 + 719 t "False" 720 1416 + 720 sem -807 34708 0 + 721 alt 0 724 719 1416 + 722 t "Nothing" 723 1417 + 723 sem -807 34788 0 + 724 alt 0 729 722 1417 + 725 t "(" 726 1418 + 726 nt Expr 727 34867 1418 + 727 t ")" 728 1418 + 728 sem -807 34888 0 + 729 alt 0 732 725 1418 + 730 nt Identifier 731 1419 + 731 sem -807 34971 0 + 732 alt 0 738 730 1419 + 733 sem 734 35024 0 + 734 nt PrimitiveTyp 735 35072 1420 + 735 t "." 736 1421 + 736 nt Identifier 737 1421 + 737 sem -807 35103 0 738 alt 0 741 733 0 - 739 t "Me" 740 1421 - 740 sem -807 35079 0 - 741 alt 0 752 739 1421 - 742 sem 747 35130 0 - 743 t "MyBase" 744 1423 - 744 sem -749 35188 0 - 745 t "MyClass" 746 1424 - 746 sem -749 35261 0 - 747 alt 749 748 743 1423 - 748 alt 0 0 745 1424 - 749 t "." 750 1426 - 750 nt IdentifierOr 751 35342 1426 - 751 sem -807 35358 0 + 739 t "Me" 740 1422 + 740 sem -807 35210 0 + 741 alt 0 752 739 1422 + 742 sem 747 35261 0 + 743 t "MyBase" 744 1424 + 744 sem -749 35319 0 + 745 t "MyClass" 746 1425 + 746 sem -749 35392 0 + 747 alt 749 748 743 1424 + 748 alt 0 0 745 1425 + 749 t "." 750 1427 + 750 nt IdentifierOr 751 35473 1427 + 751 sem -807 35489 0 752 alt 0 755 742 0 - 753 nt ObjectCreate 754 35443 1427 - 754 sem -807 35460 0 - 755 alt 0 766 753 1427 - 756 t "DirectCast" -760 1428 - 757 t "CType" -760 1428 - 758 alt 760 759 756 1428 - 759 alt 0 0 757 1428 - 760 t "(" 761 1428 - 761 nt Expr 762 35531 1428 - 762 t "," 763 1428 - 763 nt TypeName 764 35554 1428 - 764 t ")" 765 1428 - 765 sem -807 35571 0 - 766 alt 0 772 758 1428 - 767 nt CastTarget 768 35643 1429 - 768 t "(" 769 1429 - 769 nt Expr 770 35662 1429 - 770 t ")" 771 1429 - 771 sem -807 35679 0 - 772 alt 0 776 767 1429 - 773 t "AddressOf" 774 1430 - 774 nt Expr 775 35764 1430 - 775 sem -807 35779 0 - 776 alt 0 782 773 1430 - 777 t "GetType" 778 1431 - 778 t "(" 779 1431 - 779 nt TypeName 780 35863 1431 - 780 t ")" 781 1431 - 781 sem -807 35880 0 - 782 alt 0 788 777 1431 - 783 t "TypeOf" 784 1432 - 784 nt SimpleExpr 785 35958 1432 - 785 t "Is" 786 1432 - 786 nt TypeName 787 35982 1432 - 787 sem -807 35995 0 - 788 alt 0 0 783 1432 - 789 t "." 790 1435 - 790 nt IdentifierOr 791 36080 1435 - 791 sem -807 36093 0 - 792 t "(" 793 1436 - 793 sem 802 36159 0 - 794 nt Argument 795 36226 1438 - 795 sem -801 36239 0 + 753 nt ObjectCreate 754 35574 1428 + 754 sem -807 35591 0 + 755 alt 0 766 753 1428 + 756 t "DirectCast" -760 1429 + 757 t "CType" -760 1429 + 758 alt 760 759 756 1429 + 759 alt 0 0 757 1429 + 760 t "(" 761 1429 + 761 nt Expr 762 35662 1429 + 762 t "," 763 1429 + 763 nt TypeName 764 35685 1429 + 764 t ")" 765 1429 + 765 sem -807 35702 0 + 766 alt 0 772 758 1429 + 767 nt CastTarget 768 35774 1430 + 768 t "(" 769 1430 + 769 nt Expr 770 35793 1430 + 770 t ")" 771 1430 + 771 sem -807 35810 0 + 772 alt 0 776 767 1430 + 773 t "AddressOf" 774 1431 + 774 nt Expr 775 35895 1431 + 775 sem -807 35910 0 + 776 alt 0 782 773 1431 + 777 t "GetType" 778 1432 + 778 t "(" 779 1432 + 779 nt TypeName 780 35994 1432 + 780 t ")" 781 1432 + 781 sem -807 36011 0 + 782 alt 0 788 777 1432 + 783 t "TypeOf" 784 1433 + 784 nt SimpleExpr 785 36089 1433 + 785 t "Is" 786 1433 + 786 nt TypeName 787 36113 1433 + 787 sem -807 36126 0 + 788 alt 0 0 783 1433 + 789 t "." 790 1436 + 790 nt IdentifierOr 791 36211 1436 + 791 sem -807 36224 0 + 792 t "(" 793 1437 + 793 sem 802 36290 0 + 794 nt Argument 795 36357 1439 + 795 sem -801 36370 0 796 opt 801 0 794 0 - 797 t "," 800 1440 - 798 nt Argument 799 36327 1441 - 799 sem -801 36340 0 + 797 t "," 800 1441 + 798 nt Argument 799 36458 1442 + 799 sem -801 36471 0 800 opt -801 0 798 0 801 iter -803 0 797 0 802 opt 803 0 796 0 - 803 t ")" 804 1444 - 804 sem -807 36417 0 - 805 alt -807 806 789 1435 - 806 alt 0 0 792 1436 + 803 t ")" 804 1445 + 804 sem -807 36548 0 + 805 alt -807 806 789 1436 + 806 alt 0 0 792 1437 807 iter 0 0 805 0 - 808 t "." 809 1448 - 809 nt IdentifierOr 810 36556 1448 - 810 sem 831 36569 0 - 811 t "." 812 1450 - 812 nt IdentifierOr 813 36653 1450 - 813 sem -831 36666 0 - 814 t "(" 815 1451 - 815 sem 826 36731 0 - 816 sem 818 36788 0 - 817 nt Argument -819 36815 1453 + 808 t "." 809 1449 + 809 nt IdentifierOr 810 36687 1449 + 810 sem 831 36700 0 + 811 t "." 812 1451 + 812 nt IdentifierOr 813 36784 1451 + 813 sem -831 36797 0 + 814 t "(" 815 1452 + 815 sem 826 36862 0 + 816 sem 818 36919 0 + 817 nt Argument -819 36946 1454 818 opt 819 0 817 0 - 819 sem 825 36829 0 - 820 t "," 821 1455 - 821 sem 823 36896 0 - 822 nt Argument -824 36929 1456 + 819 sem 825 36960 0 + 820 t "," 821 1456 + 821 sem 823 37027 0 + 822 nt Argument -824 37060 1457 823 opt 824 0 822 0 - 824 sem -825 36945 0 + 824 sem -825 37076 0 825 iter -827 0 820 0 826 opt 827 0 816 0 - 827 t ")" 828 1459 - 828 sem -831 37016 0 - 829 alt -831 830 811 1450 - 830 alt 0 0 814 1451 + 827 t ")" 828 1460 + 828 sem -831 37147 0 + 829 alt -831 830 811 1451 + 830 alt 0 0 814 1452 831 iter 0 0 829 0 - 832 alt 0 833 699 1406 - 833 alt 0 0 808 1448 - 834 t "CBool" 835 1470 - 835 sem 0 37179 0 - 836 t "CByte" 837 1471 - 837 sem 0 37241 0 - 838 alt 0 839 834 1470 - 839 alt 0 842 836 1471 - 840 t "CChar" 841 1472 - 841 sem 0 37300 0 - 842 alt 0 845 840 1472 - 843 t "CDate" 844 1473 - 844 sem 0 37359 0 - 845 alt 0 848 843 1473 - 846 t "CDec" 847 1474 - 847 sem 0 37421 0 - 848 alt 0 851 846 1474 - 849 t "CDbl" 850 1475 - 850 sem 0 37482 0 - 851 alt 0 854 849 1475 - 852 t "CInt" 853 1476 - 853 sem 0 37542 0 - 854 alt 0 857 852 1476 - 855 t "CLng" 856 1477 - 856 sem 0 37601 0 - 857 alt 0 860 855 1477 - 858 t "CObj" 859 1478 - 859 sem 0 37660 0 - 860 alt 0 863 858 1478 - 861 t "CShort" 862 1479 - 862 sem 0 37722 0 - 863 alt 0 866 861 1479 - 864 t "CSng" 865 1480 - 865 sem 0 37781 0 - 866 alt 0 869 864 1480 - 867 t "CStr" 868 1481 - 868 sem 0 37841 0 - 869 alt 0 0 867 1481 - 870 nt ConditionalA 874 37984 1486 - 871 t "OrElse" 872 1486 - 872 nt ConditionalA 873 38028 1486 - 873 sem -874 38042 0 + 832 alt 0 833 699 1407 + 833 alt 0 0 808 1449 + 834 t "CBool" 835 1471 + 835 sem 0 37310 0 + 836 t "CByte" 837 1472 + 837 sem 0 37372 0 + 838 alt 0 839 834 1471 + 839 alt 0 842 836 1472 + 840 t "CChar" 841 1473 + 841 sem 0 37431 0 + 842 alt 0 845 840 1473 + 843 t "CDate" 844 1474 + 844 sem 0 37490 0 + 845 alt 0 848 843 1474 + 846 t "CDec" 847 1475 + 847 sem 0 37552 0 + 848 alt 0 851 846 1475 + 849 t "CDbl" 850 1476 + 850 sem 0 37613 0 + 851 alt 0 854 849 1476 + 852 t "CInt" 853 1477 + 853 sem 0 37673 0 + 854 alt 0 857 852 1477 + 855 t "CLng" 856 1478 + 856 sem 0 37732 0 + 857 alt 0 860 855 1478 + 858 t "CObj" 859 1479 + 859 sem 0 37791 0 + 860 alt 0 863 858 1479 + 861 t "CShort" 862 1480 + 862 sem 0 37853 0 + 863 alt 0 866 861 1480 + 864 t "CSng" 865 1481 + 865 sem 0 37912 0 + 866 alt 0 869 864 1481 + 867 t "CStr" 868 1482 + 868 sem 0 37972 0 + 869 alt 0 0 867 1482 + 870 nt ConditionalA 874 38115 1487 + 871 t "OrElse" 872 1487 + 872 nt ConditionalA 873 38159 1487 + 873 sem -874 38173 0 874 iter 0 0 871 0 - 875 nt InclusiveOrE 879 38228 1491 - 876 t "AndAlso" 877 1491 - 877 nt InclusiveOrE 878 38270 1491 - 878 sem -879 38284 0 + 875 nt InclusiveOrE 879 38359 1492 + 876 t "AndAlso" 877 1492 + 877 nt InclusiveOrE 878 38401 1492 + 878 sem -879 38415 0 879 iter 0 0 876 0 - 880 nt ExclusiveOrE 884 38468 1496 - 881 t "Xor" 882 1496 - 882 nt ExclusiveOrE 883 38506 1496 - 883 sem -884 38520 0 + 880 nt ExclusiveOrE 884 38599 1497 + 881 t "Xor" 882 1497 + 882 nt ExclusiveOrE 883 38637 1497 + 883 sem -884 38651 0 884 iter 0 0 881 0 - 885 nt AndExpr 889 38697 1501 - 886 t "Or" 887 1501 - 887 nt AndExpr 888 38726 1501 - 888 sem -889 38740 0 + 885 nt AndExpr 889 38828 1502 + 886 t "Or" 887 1502 + 887 nt AndExpr 888 38857 1502 + 888 sem -889 38871 0 889 iter 0 0 886 0 - 890 nt NotExpr 894 38907 1506 - 891 t "And" 892 1506 - 892 nt NotExpr 893 38936 1506 - 893 sem -894 38950 0 + 890 nt NotExpr 894 39038 1507 + 891 t "And" 892 1507 + 892 nt NotExpr 893 39067 1507 + 893 sem -894 39081 0 894 iter 0 0 891 0 - 895 t "Not" 896 1511 - 896 sem -897 39153 0 + 895 t "Not" 896 1512 + 896 sem -897 39284 0 897 iter 898 0 895 0 - 898 nt EqualityExpr 899 39202 1512 - 899 sem 0 39235 0 - 900 nt RelationalEx 912 39509 1523 - 901 t "<>" 902 1526 - 902 sem -910 39544 0 - 903 t "=" 904 1527 - 904 sem -910 39598 0 - 905 alt 910 906 901 1526 - 906 alt 0 909 903 1527 - 907 t "Like" 908 1528 - 908 sem -910 39651 0 - 909 alt 0 0 907 1528 - 910 nt RelationalEx 911 39707 1530 - 911 sem -912 39721 0 + 898 nt EqualityExpr 899 39333 1513 + 899 sem 0 39366 0 + 900 nt RelationalEx 912 39640 1524 + 901 t "<>" 902 1527 + 902 sem -910 39675 0 + 903 t "=" 904 1528 + 904 sem -910 39729 0 + 905 alt 910 906 901 1527 + 906 alt 0 909 903 1528 + 907 t "Like" 908 1529 + 908 sem -910 39782 0 + 909 alt 0 0 907 1529 + 910 nt RelationalEx 911 39838 1531 + 911 sem -912 39852 0 912 iter 0 0 905 0 - 913 nt ShiftExpr 938 39931 1539 - 914 t "<" 915 1542 - 915 sem -926 39967 0 - 916 t ">" 917 1543 - 917 sem -926 40018 0 - 918 alt 926 919 914 1542 - 919 alt 0 922 916 1543 - 920 t "<=" 921 1544 - 921 sem -926 40072 0 - 922 alt 0 925 920 1544 - 923 t ">=" 924 1545 - 924 sem -926 40130 0 - 925 alt 0 0 923 1545 - 926 nt ShiftExpr 927 40195 1547 - 927 sem -938 40209 0 - 928 t "Is" 929 1550 - 929 sem -934 40305 0 - 930 t "IsNot" 931 1551 - 931 sem -934 40352 0 - 932 alt 934 933 928 1550 - 933 alt 0 0 930 1551 - 934 nt Expr 935 40396 1552 - 935 sem -938 40410 0 - 936 alt -938 937 918 1542 - 937 alt 0 0 932 1550 + 913 nt ShiftExpr 938 40062 1540 + 914 t "<" 915 1543 + 915 sem -926 40098 0 + 916 t ">" 917 1544 + 917 sem -926 40149 0 + 918 alt 926 919 914 1543 + 919 alt 0 922 916 1544 + 920 t "<=" 921 1545 + 921 sem -926 40203 0 + 922 alt 0 925 920 1545 + 923 t ">=" 924 1546 + 924 sem -926 40261 0 + 925 alt 0 0 923 1546 + 926 nt ShiftExpr 927 40326 1548 + 927 sem -938 40340 0 + 928 t "Is" 929 1551 + 929 sem -934 40436 0 + 930 t "IsNot" 931 1552 + 931 sem -934 40498 0 + 932 alt 934 933 928 1551 + 933 alt 0 0 930 1552 + 934 nt Expr 935 40556 1553 + 935 sem -938 40570 0 + 936 alt -938 937 918 1543 + 937 alt 0 0 932 1551 938 iter 0 0 936 0 - 939 nt AdditiveExpr 948 40616 1561 - 940 t "<<" 941 1564 - 941 sem -946 40653 0 - 942 t ">>" 943 1565 - 943 sem -946 40705 0 - 944 alt 946 945 940 1564 - 945 alt 0 0 942 1565 - 946 nt AdditiveExpr 947 40765 1567 - 947 sem -948 40779 0 + 939 nt AdditiveExpr 948 40776 1562 + 940 t "<<" 941 1565 + 941 sem -946 40813 0 + 942 t ">>" 943 1566 + 943 sem -946 40865 0 + 944 alt 946 945 940 1565 + 945 alt 0 0 942 1566 + 946 nt AdditiveExpr 947 40925 1568 + 947 sem -948 40939 0 948 iter 0 0 944 0 - 949 nt Multiplicati 961 40996 1576 - 950 t "+" 951 1579 - 951 sem -959 41033 0 - 952 t "-" 953 1580 - 953 sem -959 41078 0 - 954 alt 959 955 950 1579 - 955 alt 0 958 952 1580 - 956 t "&" 957 1581 - 957 sem -959 41128 0 - 958 alt 0 0 956 1581 - 959 nt Multiplicati 960 41190 1583 - 960 sem -961 41204 0 + 949 nt Multiplicati 961 41156 1577 + 950 t "+" 951 1580 + 951 sem -959 41193 0 + 952 t "-" 953 1581 + 953 sem -959 41238 0 + 954 alt 959 955 950 1580 + 955 alt 0 958 952 1581 + 956 t "&" 957 1582 + 957 sem -959 41288 0 + 958 alt 0 0 956 1582 + 959 nt Multiplicati 960 41350 1584 + 960 sem -961 41364 0 961 iter 0 0 954 0 - 962 nt UnaryExpr 980 41413 1592 - 963 t "*" 964 1595 - 964 sem -978 41448 0 - 965 t "/" 966 1596 - 966 sem -978 41498 0 - 967 alt 978 968 963 1595 - 968 alt 0 971 965 1596 - 969 t "\\" 970 1597 - 970 sem -978 41547 0 - 971 alt 0 974 969 1597 - 972 t "Mod" 973 1598 - 973 sem -978 41604 0 - 974 alt 0 977 972 1598 - 975 t "^" 976 1599 - 976 sem -978 41653 0 - 977 alt 0 0 975 1599 - 978 nt UnaryExpr 979 41706 1601 - 979 sem -980 41719 0 + 962 nt UnaryExpr 980 41573 1593 + 963 t "*" 964 1596 + 964 sem -978 41608 0 + 965 t "/" 966 1597 + 966 sem -978 41658 0 + 967 alt 978 968 963 1596 + 968 alt 0 971 965 1597 + 969 t "\\" 970 1598 + 970 sem -978 41707 0 + 971 alt 0 974 969 1598 + 972 t "Mod" 973 1599 + 973 sem -978 41764 0 + 974 alt 0 977 972 1599 + 975 t "^" 976 1600 + 976 sem -978 41813 0 + 977 alt 0 0 975 1600 + 978 nt UnaryExpr 979 41866 1602 + 979 sem -980 41879 0 980 iter 0 0 967 0 - 981 t "New" 982 1611 - 982 nt TypeNameWith 987 41982 1611 - 983 t "(" 985 1612 - 984 nt ArgumentList -986 42014 1612 + 981 t "New" 982 1612 + 982 nt TypeNameWith 987 42142 1612 + 983 t "(" 985 1613 + 984 nt ArgumentList -986 42174 1613 985 opt 986 0 984 0 - 986 t ")" -989 1612 + 986 t ")" -989 1613 987 opt 989 0 983 0 - 988 nt ArrayInitial -990 42058 1613 + 988 nt ArrayInitial -990 42218 1614 989 opt 990 0 988 0 - 990 sem 0 42085 0 - 991 nt Argument 992 42489 1632 - 992 sem 996 42504 0 - 993 t "," 994 1634 - 994 nt Argument 995 42576 1635 - 995 sem -996 42590 0 + 990 sem 0 42245 0 + 991 nt Argument 992 42649 1633 + 992 sem 996 42664 0 + 993 t "," 994 1635 + 994 nt Argument 995 42736 1636 + 995 sem -996 42750 0 996 iter 0 0 993 0 997 opt 0 0 991 0 - 998 rslv 999 1647 - 999 nt Identifier 1000 1647 -1000 sem 1001 42816 0 -1001 t ":" 1002 1647 -1002 t "=" 1003 1647 -1003 nt Expr 1004 42847 1647 -1004 sem 0 42865 0 -1005 nt Expr 0 42937 1652 -1006 alt 0 1007 998 1647 -1007 alt 0 0 1005 1652 -1008 nt NonArrayType 1009 43080 1658 -1009 sem 0 43101 0 -1010 nt NonArrayType 1011 43319 1668 -1011 nt ArrayTypeMod 1012 43353 1669 -1012 sem 0 43371 0 -1013 nt Qualident 1014 43634 1683 -1014 sem 0 43647 0 -1015 t "Object" 1016 1684 -1016 sem 0 43701 0 -1017 alt 0 1018 1013 1683 -1018 alt 0 1021 1015 1684 -1019 nt PrimitiveTyp 1020 43772 1685 -1020 sem 0 43785 0 -1021 alt 0 0 1019 1685 -1022 nt ArrayTypeMod 0 43948 1693 -1023 rslv 1024 1703 -1024 t "(" 1026 1704 -1025 nt RankList -1027 44139 1705 + 998 rslv 999 1648 + 999 nt Identifier 1000 1648 +1000 sem 1001 42976 0 +1001 t ":" 1002 1648 +1002 t "=" 1003 1648 +1003 nt Expr 1004 43007 1648 +1004 sem 0 43025 0 +1005 nt Expr 0 43097 1653 +1006 alt 0 1007 998 1648 +1007 alt 0 0 1005 1653 +1008 nt NonArrayType 1009 43240 1659 +1009 sem 0 43261 0 +1010 nt NonArrayType 1011 43479 1669 +1011 nt ArrayTypeMod 1012 43513 1670 +1012 sem 0 43531 0 +1013 nt Qualident 1014 43794 1684 +1014 sem 0 43807 0 +1015 t "Object" 1016 1685 +1016 sem 0 43861 0 +1017 alt 0 1018 1013 1684 +1018 alt 0 1021 1015 1685 +1019 nt PrimitiveTyp 1020 43932 1686 +1020 sem 0 43945 0 +1021 alt 0 0 1019 1686 +1022 nt ArrayTypeMod 0 44108 1694 +1023 rslv 1024 1704 +1024 t "(" 1026 1705 +1025 nt RankList -1027 44299 1706 1026 opt 1027 0 1025 0 -1027 sem 1028 44157 0 -1028 t ")" -1029 1709 +1027 sem 1028 44317 0 +1028 t ")" -1029 1710 1029 iter 1030 0 1023 0 -1030 sem 0 44205 0 -1031 t "," 1032 1721 -1032 sem -1033 44341 0 +1030 sem 0 44365 0 +1031 t "," 1032 1722 +1032 sem -1033 44501 0 1033 iter 0 0 1031 0 -1034 sem 1035 44388 0 -1035 t "<" 1038 1726 -1036 t "Assembly" -1040 1726 -1037 t "Module" -1040 1726 -1038 alt 1040 1039 1036 1726 -1039 alt 0 0 1037 1726 -1040 sem 1041 44460 0 -1041 t ":" 1042 1731 -1042 nt Attribute 1043 44622 1731 -1043 sem 1054 44640 0 -1044 rslv 1051 1732 -1045 t "," 1048 1732 -1046 t "Assembly" -1050 1732 -1047 t "Module" -1050 1732 -1048 alt 1050 1049 1046 1732 -1049 alt 0 0 1047 1732 -1050 t ":" -1052 1732 +1034 sem 1035 44548 0 +1035 t "<" 1038 1727 +1036 t "Assembly" -1040 1727 +1037 t "Module" -1040 1727 +1038 alt 1040 1039 1036 1727 +1039 alt 0 0 1037 1727 +1040 sem 1041 44620 0 +1041 t ":" 1042 1732 +1042 nt Attribute 1043 44782 1732 +1043 sem 1054 44800 0 +1044 rslv 1051 1733 +1045 t "," 1048 1733 +1046 t "Assembly" -1050 1733 +1047 t "Module" -1050 1733 +1048 alt 1050 1049 1046 1733 +1049 alt 0 0 1047 1733 +1050 t ":" -1052 1733 1051 opt 1052 0 1045 0 -1052 nt Attribute 1053 44739 1732 -1053 sem -1054 44757 0 +1052 nt Attribute 1053 44899 1733 +1053 sem -1054 44917 0 1054 iter 1056 0 1044 0 -1055 t "," -1057 1733 +1055 t "," -1057 1734 1056 opt 1057 0 1055 0 -1057 t ">" 1058 1734 -1058 nt EndOfStmt 1059 1735 -1059 sem 0 44826 0 -1060 nt Qualident 1061 45160 1747 -1061 sem 1063 45180 0 -1062 nt AttributeArg -1064 45314 1751 +1057 t ">" 1058 1735 +1058 nt EndOfStmt 1059 1736 +1059 sem 0 44986 0 +1060 nt Qualident 1061 45320 1748 +1061 sem 1063 45340 0 +1062 nt AttributeArg -1064 45474 1752 1063 opt 1064 0 1062 0 -1064 sem 0 45351 0 -1065 t "(" 1089 1764 -1066 rslv 1073 1766 -1067 rslv 1068 1768 -1068 sem 1069 45697 0 -1069 nt IdentifierOr 1071 45743 1769 -1070 t ":" -1072 1770 +1064 sem 0 45511 0 +1065 t "(" 1089 1765 +1066 rslv 1073 1767 +1067 rslv 1068 1769 +1068 sem 1069 45857 0 +1069 nt IdentifierOr 1071 45903 1770 +1070 t ":" -1072 1771 1071 opt 1072 0 1070 0 -1072 t "=" -1074 1770 +1072 t "=" -1074 1771 1073 opt 1074 0 1067 0 -1074 nt Expr 1075 45779 1771 -1075 sem 1088 45803 0 -1076 t "," 1084 1778 -1077 rslv 1078 1780 -1078 sem 1079 46008 0 -1079 nt IdentifierOr 1081 46056 1781 -1080 t ":" -1082 1782 +1074 nt Expr 1075 45939 1772 +1075 sem 1088 45963 0 +1076 t "," 1084 1779 +1077 rslv 1078 1781 +1078 sem 1079 46168 0 +1079 nt IdentifierOr 1081 46216 1782 +1080 t ":" -1082 1783 1081 opt 1082 0 1080 0 -1082 t "=" -1086 1782 -1083 sem -1086 46097 0 -1084 alt 1086 1085 1077 1780 +1082 t "=" -1086 1783 +1083 sem -1086 46257 0 +1084 alt 1086 1085 1077 1781 1085 alt 0 0 1083 0 -1086 nt Expr 1087 46182 1784 -1087 sem -1088 46196 0 +1086 nt Expr 1087 46342 1785 +1087 sem -1088 46356 0 1088 iter -1090 0 1076 0 1089 opt 1090 0 1066 0 -1090 t ")" 0 1791 -1091 t "<" 1092 1801 -1092 sem 1104 46610 0 -1093 rslv 1098 1802 -1094 t "Event" 1095 1803 -1095 sem -1103 46688 0 -1096 t "Return" 1097 1804 -1097 sem -1103 46735 0 -1098 alt 1103 1099 1094 1803 -1099 alt 0 1102 1096 1804 -1100 nt Identifier 1101 1805 -1101 sem -1103 46793 0 -1102 alt 0 0 1100 1805 -1103 t ":" -1105 1815 +1090 t ")" 0 1792 +1091 t "<" 1092 1802 +1092 sem 1104 46770 0 +1093 rslv 1098 1803 +1094 t "Event" 1095 1804 +1095 sem -1103 46848 0 +1096 t "Return" 1097 1805 +1097 sem -1103 46895 0 +1098 alt 1103 1099 1094 1804 +1099 alt 0 1102 1096 1805 +1100 nt Identifier 1101 1806 +1101 sem -1103 46953 0 +1102 alt 0 0 1100 1806 +1103 t ":" -1105 1816 1104 opt 1105 0 1093 0 -1105 nt Attribute 1106 47145 1817 -1106 sem 1111 47163 0 -1107 rslv 1108 1818 -1108 t "," 1109 1818 -1109 nt Attribute 1110 47232 1818 -1110 sem -1111 47250 0 +1105 nt Attribute 1106 47305 1818 +1106 sem 1111 47323 0 +1107 rslv 1108 1819 +1108 t "," 1109 1819 +1109 nt Attribute 1110 47392 1819 +1110 sem -1111 47410 0 1111 iter 1113 0 1107 0 -1112 t "," -1114 1819 +1112 t "," -1114 1820 1113 opt 1114 0 1112 0 -1114 t ">" 1115 1820 -1115 sem 0 47308 0 -1116 nt AttributeSec 1117 47690 1835 -1117 sem -1118 47705 0 +1114 t ">" 1115 1821 +1115 sem 0 47468 0 +1116 nt AttributeSec 1117 47850 1836 +1117 sem -1118 47865 0 1118 iter 1119 0 1116 0 -1119 nt FormalParame 1120 47758 1837 -1120 sem 1128 47775 0 -1121 t "," 1122 1844 -1122 sem 1125 47876 0 -1123 nt AttributeSec 1124 47975 1845 -1124 sem -1125 47990 0 +1119 nt FormalParame 1120 47918 1838 +1120 sem 1128 47935 0 +1121 t "," 1122 1845 +1122 sem 1125 48036 0 +1123 nt AttributeSec 1124 48135 1846 +1124 sem -1125 48150 0 1125 iter 1126 0 1123 0 -1126 nt FormalParame 1127 48048 1847 -1127 sem -1128 48058 0 +1126 nt FormalParame 1127 48208 1848 +1127 sem -1128 48218 0 1128 iter 0 0 1121 0 -1129 nt ParameterMod -1130 48379 1860 +1129 nt ParameterMod -1130 48539 1861 1130 iter 1131 0 1129 0 -1131 nt Identifier 1132 1861 -1132 sem 1135 48402 0 -1133 rslv 1134 1862 -1134 nt ArrayTypeMod -1138 48471 1862 +1131 nt Identifier 1132 1862 +1132 sem 1135 48562 0 +1133 rslv 1134 1863 +1134 nt ArrayTypeMod -1138 48631 1863 1135 opt 1138 0 1133 0 -1136 t "As" 1137 1863 -1137 nt TypeName -1139 48511 1863 +1136 t "As" 1137 1864 +1137 nt TypeName -1139 48671 1864 1138 opt 1139 0 1136 0 -1139 sem 1142 48531 0 -1140 t "=" 1141 1877 -1141 nt Expr -1143 48928 1877 +1139 sem 1142 48691 0 +1140 t "=" 1141 1878 +1141 nt Expr -1143 49088 1878 1142 opt 1143 0 1140 0 -1143 sem 0 48948 0 -1144 sem 1153 49107 0 -1145 rslv 1146 1893 -1146 t "End" 1147 1893 -1147 nt EndOfStmt 1148 1893 -1148 sem -1153 49294 0 -1149 nt Statement 1150 1894 -1150 nt EndOfStmt -1153 1894 -1151 alt -1153 1152 1145 1893 -1152 alt 0 0 1149 1894 +1143 sem 0 49108 0 +1144 sem 1153 49267 0 +1145 rslv 1146 1894 +1146 t "End" 1147 1894 +1147 nt EndOfStmt 1148 1894 +1148 sem -1153 49454 0 +1149 nt Statement 1150 1895 +1150 nt EndOfStmt -1153 1895 +1151 alt -1153 1152 1145 1894 +1152 alt 0 0 1149 1895 1153 iter 1154 0 1151 0 -1154 sem 0 49415 0 +1154 sem 0 49575 0 1155 eps -1169 0 -1156 rslv 1157 1913 -1157 nt LabelName 1158 49669 1913 -1158 sem 1159 49690 0 -1159 t ":" 1160 1917 -1160 nt Statement -1169 1917 +1156 rslv 1157 1914 +1157 nt LabelName 1158 49829 1914 +1158 sem 1159 49850 0 +1159 t ":" 1160 1918 +1160 nt Statement -1169 1918 1161 alt 1169 1162 1155 0 -1162 alt 0 1165 1156 1913 -1163 nt EmbeddedStat 1164 49789 1918 -1164 sem -1169 49804 0 -1165 alt 0 1168 1163 1918 -1166 nt LocalDeclara 1167 49870 1919 -1167 sem -1169 49883 0 -1168 alt 0 0 1166 1919 -1169 sem 0 49930 0 -1170 t "Const" 1171 1938 -1171 sem -1179 50312 0 -1172 t "Static" 1173 1939 -1173 sem -1179 50355 0 -1174 alt -1179 1175 1170 1938 -1175 alt 0 1178 1172 1939 -1176 t "Dim" 1177 1940 -1177 sem -1179 50397 0 -1178 alt 0 0 1176 1940 +1162 alt 0 1165 1156 1914 +1163 nt EmbeddedStat 1164 49949 1919 +1164 sem -1169 49964 0 +1165 alt 0 1168 1163 1919 +1166 nt LocalDeclara 1167 50030 1920 +1167 sem -1169 50043 0 +1168 alt 0 0 1166 1920 +1169 sem 0 50090 0 +1170 t "Const" 1171 1939 +1171 sem -1179 50472 0 +1172 t "Static" 1173 1940 +1173 sem -1179 50515 0 +1174 alt -1179 1175 1170 1939 +1175 alt 0 1178 1172 1940 +1176 t "Dim" 1177 1941 +1177 sem -1179 50557 0 +1178 alt 0 0 1176 1941 1179 iter 1180 0 1174 0 -1180 sem 1181 50429 0 -1181 nt VariableDecl 1184 50784 1954 -1182 t "," 1183 1955 -1183 nt VariableDecl -1184 50847 1955 +1180 sem 1181 50589 0 +1181 nt VariableDecl 1184 50944 1955 +1182 t "," 1183 1956 +1183 nt VariableDecl -1184 51007 1956 1184 iter 1185 0 1182 0 -1185 sem 0 50893 0 -1186 t "Exit" 1187 1968 -1187 sem 1192 51151 0 -1188 t "Sub" 1189 1970 -1189 sem -1212 51209 0 -1190 t "Function" 1191 1972 -1191 sem -1212 51261 0 -1192 alt 1212 1193 1188 1970 -1193 alt 0 1196 1190 1972 -1194 t "Property" 1195 1974 -1195 sem -1212 51318 0 -1196 alt 0 1199 1194 1974 -1197 t "Do" 1198 1976 -1198 sem -1212 51370 0 -1199 alt 0 1202 1197 1976 -1200 t "For" 1201 1978 -1201 sem -1212 51417 0 -1202 alt 0 1205 1200 1978 -1203 t "Try" 1204 1980 -1204 sem -1212 51465 0 -1205 alt 0 1208 1203 1980 -1206 t "While" 1207 1982 -1207 sem -1212 51515 0 -1208 alt 0 1211 1206 1982 -1209 t "Select" 1210 1984 -1210 sem -1212 51567 0 -1211 alt 0 0 1209 1984 -1212 sem 0 51608 0 -1213 nt TryStatement 0 51669 1987 -1214 alt 0 1215 1186 1968 -1215 alt 0 1229 1213 1987 -1216 t "Continue" 1217 1988 -1217 sem 1227 51702 0 -1218 t "Do" 1219 1988 -1219 sem -1228 51762 0 -1220 t "For" 1221 1988 -1221 sem -1228 51808 0 -1222 alt -1228 1223 1218 1988 -1223 alt 0 1226 1220 1988 -1224 t "While" 1225 1988 -1225 sem -1228 51857 0 -1226 alt 0 0 1224 1988 +1185 sem 0 51053 0 +1186 t "Exit" 1187 1969 +1187 sem 1192 51311 0 +1188 t "Sub" 1189 1971 +1189 sem -1212 51369 0 +1190 t "Function" 1191 1973 +1191 sem -1212 51421 0 +1192 alt 1212 1193 1188 1971 +1193 alt 0 1196 1190 1973 +1194 t "Property" 1195 1975 +1195 sem -1212 51478 0 +1196 alt 0 1199 1194 1975 +1197 t "Do" 1198 1977 +1198 sem -1212 51530 0 +1199 alt 0 1202 1197 1977 +1200 t "For" 1201 1979 +1201 sem -1212 51577 0 +1202 alt 0 1205 1200 1979 +1203 t "Try" 1204 1981 +1204 sem -1212 51625 0 +1205 alt 0 1208 1203 1981 +1206 t "While" 1207 1983 +1207 sem -1212 51675 0 +1208 alt 0 1211 1206 1983 +1209 t "Select" 1210 1985 +1210 sem -1212 51727 0 +1211 alt 0 0 1209 1985 +1212 sem 0 51768 0 +1213 nt TryStatement 0 51829 1988 +1214 alt 0 1215 1186 1969 +1215 alt 0 1229 1213 1988 +1216 t "Continue" 1217 1989 +1217 sem 1227 51862 0 +1218 t "Do" 1219 1989 +1219 sem -1228 51922 0 +1220 t "For" 1221 1989 +1221 sem -1228 51968 0 +1222 alt -1228 1223 1218 1989 +1223 alt 0 1226 1220 1989 +1224 t "While" 1225 1989 +1225 sem -1228 52017 0 +1226 alt 0 0 1224 1989 1227 opt 1228 0 1222 0 -1228 sem 0 51899 0 -1229 alt 0 1234 1216 1988 -1230 t "Throw" 1232 1990 -1231 nt Expr -1233 51988 1990 +1228 sem 0 52059 0 +1229 alt 0 1234 1216 1989 +1230 t "Throw" 1232 1991 +1231 nt Expr -1233 52148 1991 1232 opt 1233 0 1231 0 -1233 sem 0 52006 0 -1234 alt 0 1239 1230 1990 -1235 t "Return" 1237 1992 -1236 nt Expr -1238 52081 1992 +1233 sem 0 52166 0 +1234 alt 0 1239 1230 1991 +1235 t "Return" 1237 1993 +1236 nt Expr -1238 52241 1993 1237 opt 1238 0 1236 0 -1238 sem 0 52099 0 -1239 alt 0 1247 1235 1992 -1240 t "SyncLock" 1241 1994 -1241 nt Expr 1242 52174 1994 -1242 nt EndOfStmt 1243 1994 -1243 nt Block 1244 52200 1994 -1244 t "End" 1245 1995 -1245 t "SyncLock" 1246 1995 -1246 sem 0 52251 0 -1247 alt 0 1257 1240 1994 -1248 t "RaiseEvent" 1249 1997 -1249 nt Identifier 1250 1997 -1250 sem 1255 52356 0 -1251 t "(" 1253 1998 -1252 nt ArgumentList -1254 52396 1998 +1238 sem 0 52259 0 +1239 alt 0 1247 1235 1993 +1240 t "SyncLock" 1241 1995 +1241 nt Expr 1242 52334 1995 +1242 nt EndOfStmt 1243 1995 +1243 nt Block 1244 52360 1995 +1244 t "End" 1245 1996 +1245 t "SyncLock" 1246 1996 +1246 sem 0 52411 0 +1247 alt 0 1257 1240 1995 +1248 t "RaiseEvent" 1249 1998 +1249 nt Identifier 1250 1998 +1250 sem 1255 52516 0 +1251 t "(" 1253 1999 +1252 nt ArgumentList -1254 52556 1999 1253 opt 1254 0 1252 0 -1254 t ")" -1256 1998 +1254 t ")" -1256 1999 1255 opt 1256 0 1251 0 -1256 sem 0 52416 0 -1257 alt 0 1259 1248 1997 -1258 nt WithStatemen 0 52496 2001 -1259 alt 0 1266 1258 2001 -1260 t "AddHandler" 1261 2003 -1261 sem 1262 52546 0 -1262 nt Expr 1263 52587 2004 -1263 t "," 1264 2004 -1264 nt Expr 1265 52606 2004 -1265 sem 0 52631 0 -1266 alt 0 1273 1260 2003 -1267 t "RemoveHandl 1268 2009 -1268 sem 1269 52730 0 -1269 nt Expr 1270 52771 2010 -1270 t "," 1271 2010 -1271 nt Expr 1272 52790 2010 -1272 sem 0 52815 0 -1273 alt 0 1281 1267 2009 -1274 t "While" 1275 2015 -1275 nt Expr 1276 52911 2015 -1276 nt EndOfStmt 1277 2015 -1277 nt Block 1278 52939 2016 -1278 t "End" 1279 2016 -1279 t "While" 1280 2016 -1280 sem 0 52984 0 -1281 alt 0 1299 1274 2015 -1282 t "Do" 1283 2021 -1283 sem 1297 53125 0 -1284 nt WhileOrUntil 1285 53200 2026 -1285 nt Expr 1286 53224 2026 -1286 nt EndOfStmt 1287 2026 -1287 nt Block 1288 53253 2027 -1288 t "Loop" 1289 2028 -1289 sem 0 53296 0 -1290 nt EndOfStmt 1291 2036 -1291 nt Block 1292 53601 2037 -1292 t "Loop" 1295 2038 -1293 nt WhileOrUntil 1294 53648 2038 -1294 nt Expr -1296 53672 2038 +1256 sem 0 52576 0 +1257 alt 0 1259 1248 1998 +1258 nt WithStatemen 0 52656 2002 +1259 alt 0 1266 1258 2002 +1260 t "AddHandler" 1261 2004 +1261 sem 1262 52706 0 +1262 nt Expr 1263 52747 2005 +1263 t "," 1264 2005 +1264 nt Expr 1265 52766 2005 +1265 sem 0 52791 0 +1266 alt 0 1273 1260 2004 +1267 t "RemoveHandl 1268 2010 +1268 sem 1269 52890 0 +1269 nt Expr 1270 52931 2011 +1270 t "," 1271 2011 +1271 nt Expr 1272 52950 2011 +1272 sem 0 52975 0 +1273 alt 0 1281 1267 2010 +1274 t "While" 1275 2016 +1275 nt Expr 1276 53071 2016 +1276 nt EndOfStmt 1277 2016 +1277 nt Block 1278 53099 2017 +1278 t "End" 1279 2017 +1279 t "While" 1280 2017 +1280 sem 0 53144 0 +1281 alt 0 1299 1274 2016 +1282 t "Do" 1283 2022 +1283 sem 1297 53285 0 +1284 nt WhileOrUntil 1285 53360 2027 +1285 nt Expr 1286 53384 2027 +1286 nt EndOfStmt 1287 2027 +1287 nt Block 1288 53413 2028 +1288 t "Loop" 1289 2029 +1289 sem 0 53456 0 +1290 nt EndOfStmt 1291 2037 +1291 nt Block 1292 53761 2038 +1292 t "Loop" 1295 2039 +1293 nt WhileOrUntil 1294 53808 2039 +1294 nt Expr -1296 53832 2039 1295 opt 1296 0 1293 0 -1296 sem 0 53693 0 -1297 alt 0 1298 1284 2026 -1298 alt 0 0 1290 2036 -1299 alt 0 1334 1282 2021 -1300 t "For" 1301 2043 -1301 sem 1332 53818 0 -1302 t "Each" 1303 2052 -1303 nt LoopControlV 1304 53999 2052 -1304 t "In" 1305 2053 -1305 nt Expr 1306 54045 2053 -1306 nt EndOfStmt 1307 2053 -1307 nt Block 1308 54075 2054 -1308 t "Next" 1310 2055 -1309 nt Expr -1311 54115 2055 +1296 sem 0 53853 0 +1297 alt 0 1298 1284 2027 +1298 alt 0 0 1290 2037 +1299 alt 0 1334 1282 2022 +1300 t "For" 1301 2044 +1301 sem 1332 53978 0 +1302 t "Each" 1303 2053 +1303 nt LoopControlV 1304 54159 2053 +1304 t "In" 1305 2054 +1305 nt Expr 1306 54205 2054 +1306 nt EndOfStmt 1307 2054 +1307 nt Block 1308 54235 2055 +1308 t "Next" 1310 2056 +1309 nt Expr -1311 54275 2056 1310 opt 1311 0 1309 0 -1311 sem 0 54137 0 -1312 sem 1313 54508 0 -1313 nt LoopControlV 1314 54682 2073 -1314 t "=" 1315 2074 -1315 nt Expr 1316 54727 2074 -1316 t "To" 1317 2074 -1317 nt Expr 1320 54748 2074 -1318 t "Step" 1319 2074 -1319 nt Expr -1321 54771 2074 +1311 sem 0 54297 0 +1312 sem 1313 54668 0 +1313 nt LoopControlV 1314 54842 2074 +1314 t "=" 1315 2075 +1315 nt Expr 1316 54887 2075 +1316 t "To" 1317 2075 +1317 nt Expr 1320 54908 2075 +1318 t "Step" 1319 2075 +1319 nt Expr -1321 54931 2075 1320 opt 1321 0 1318 0 -1321 nt EndOfStmt 1322 2075 -1322 nt Block 1323 54802 2075 -1323 t "Next" 1330 2076 -1324 nt Expr 1325 54849 2078 -1325 sem 1329 54866 0 -1326 t "," 1327 2079 -1327 nt Expr 1328 54951 2079 -1328 sem -1329 54968 0 +1321 nt EndOfStmt 1322 2076 +1322 nt Block 1323 54962 2076 +1323 t "Next" 1330 2077 +1324 nt Expr 1325 55009 2079 +1325 sem 1329 55026 0 +1326 t "," 1327 2080 +1327 nt Expr 1328 55111 2080 +1328 sem -1329 55128 0 1329 iter -1331 0 1326 0 1330 opt 1331 0 1324 0 -1331 sem 0 55019 0 -1332 alt 0 1333 1302 2052 +1331 sem 0 55179 0 +1332 alt 0 1333 1302 2053 1333 alt 0 0 1312 0 -1334 alt 0 1338 1300 2043 -1335 t "Error" 1336 2086 -1336 nt Expr 1337 55177 2086 -1337 sem 0 55194 0 -1338 alt 0 1350 1335 2086 -1339 t "ReDim" 1340 2088 -1340 sem 1343 55266 0 -1341 t "Preserve" 1342 2088 -1342 sem -1344 55341 0 +1334 alt 0 1338 1300 2044 +1335 t "Error" 1336 2087 +1336 nt Expr 1337 55337 2087 +1337 sem 0 55354 0 +1338 alt 0 1350 1335 2087 +1339 t "ReDim" 1340 2089 +1340 sem 1343 55426 0 +1341 t "Preserve" 1342 2089 +1342 sem -1344 55501 0 1343 opt 1344 0 1341 0 -1344 nt Expr 1345 55372 2089 -1345 sem 1349 55397 0 -1346 t "," 1347 2095 -1347 nt Expr 1348 55583 2095 -1348 sem -1349 55603 0 +1344 nt Expr 1345 55532 2090 +1345 sem 1349 55557 0 +1346 t "," 1347 2096 +1347 nt Expr 1348 55743 2096 +1348 sem -1349 55763 0 1349 iter 0 0 1346 0 -1350 alt 0 1359 1339 2088 -1351 t "Erase" 1352 2097 -1352 nt Expr 1353 55714 2098 -1353 sem 1357 55728 0 -1354 t "," 1355 2104 -1355 nt Expr 1356 55891 2104 -1356 sem -1357 55904 0 +1350 alt 0 1359 1339 2089 +1351 t "Erase" 1352 2098 +1352 nt Expr 1353 55874 2099 +1353 sem 1357 55888 0 +1354 t "," 1355 2105 +1355 nt Expr 1356 56051 2105 +1356 sem -1357 56064 0 1357 iter 1358 0 1354 0 -1358 sem 0 55953 0 -1359 alt 0 1362 1351 2097 -1360 t "Stop" 1361 2107 -1361 sem 0 56012 0 -1362 alt 0 1414 1360 2107 -1363 t "If" 1364 2109 -1364 nt Expr 1366 56077 2109 -1365 t "Then" -1395 2109 +1358 sem 0 56113 0 +1359 alt 0 1362 1351 2098 +1360 t "Stop" 1361 2108 +1361 sem 0 56172 0 +1362 alt 0 1414 1360 2108 +1363 t "If" 1364 2110 +1364 nt Expr 1366 56237 2110 +1365 t "Then" -1395 2110 1366 opt 1395 0 1365 0 -1367 rslv 1368 2111 -1368 t "End" 1369 2111 -1369 sem 0 56138 0 -1370 nt EndOfStmt 1371 2114 -1371 nt Block 1372 56257 2114 -1372 sem 1386 56290 0 -1373 rslv 1374 2120 -1374 t "Else" 1375 2120 -1375 t "If" -1379 2120 -1376 t "ElseIf" -1379 2121 -1377 alt 1379 1378 1373 2120 -1378 alt 0 0 1376 2121 -1379 sem 1380 56444 0 -1380 nt Expr 1382 56509 2124 -1381 t "Then" -1383 2124 +1367 rslv 1368 2112 +1368 t "End" 1369 2112 +1369 sem 0 56298 0 +1370 nt EndOfStmt 1371 2115 +1371 nt Block 1372 56417 2115 +1372 sem 1386 56450 0 +1373 rslv 1374 2121 +1374 t "Else" 1375 2121 +1375 t "If" -1379 2121 +1376 t "ElseIf" -1379 2122 +1377 alt 1379 1378 1373 2121 +1378 alt 0 0 1376 2122 +1379 sem 1380 56604 0 +1380 nt Expr 1382 56669 2125 +1381 t "Then" -1383 2125 1382 opt 1383 0 1381 0 -1383 nt EndOfStmt 1384 2124 -1384 nt Block 1385 56554 2125 -1385 sem -1386 56577 0 +1383 nt EndOfStmt 1384 2125 +1384 nt Block 1385 56714 2126 +1385 sem -1386 56737 0 1386 iter 1391 0 1377 0 -1387 t "Else" 1388 2131 -1388 nt EndOfStmt 1389 2131 -1389 nt Block 1390 56694 2132 -1390 sem -1392 56729 0 +1387 t "Else" 1388 2132 +1388 nt EndOfStmt 1389 2132 +1389 nt Block 1390 56854 2133 +1390 sem -1392 56889 0 1391 opt 1392 0 1387 0 -1392 t "End" 1393 2136 -1393 t "If" 1394 2136 -1394 sem 0 56813 0 -1395 alt 0 1396 1367 2111 -1396 alt 0 1413 1370 2114 -1397 nt EmbeddedStat 1398 56900 2141 -1398 sem 1402 56933 0 -1399 t ":" 1400 2145 -1400 nt EmbeddedStat 1401 57042 2145 -1401 sem -1402 57068 0 +1392 t "End" 1393 2137 +1393 t "If" 1394 2137 +1394 sem 0 56973 0 +1395 alt 0 1396 1367 2112 +1396 alt 0 1413 1370 2115 +1397 nt EmbeddedStat 1398 57060 2142 +1398 sem 1402 57093 0 +1399 t ":" 1400 2146 +1400 nt EmbeddedStat 1401 57202 2146 +1401 sem -1402 57228 0 1402 iter 1411 0 1399 0 -1403 t "Else" 1405 2147 -1404 nt EmbeddedStat -1406 57159 2147 +1403 t "Else" 1405 2148 +1404 nt EmbeddedStat -1406 57319 2148 1405 opt 1406 0 1404 0 -1406 sem 1410 57196 0 -1407 t ":" 1408 2152 -1408 nt EmbeddedStat 1409 57287 2152 -1409 sem -1410 57318 0 +1406 sem 1410 57356 0 +1407 t ":" 1408 2153 +1408 nt EmbeddedStat 1409 57447 2153 +1409 sem -1410 57478 0 1410 iter -1412 0 1407 0 1411 opt 1412 0 1403 0 -1412 sem 0 57389 0 -1413 alt 0 0 1397 2141 -1414 alt 0 1435 1363 2109 -1415 t "Select" 1417 2159 -1416 t "Case" -1418 2159 +1412 sem 0 57549 0 +1413 alt 0 0 1397 2142 +1414 alt 0 1435 1363 2110 +1415 t "Select" 1417 2160 +1416 t "Case" -1418 2160 1417 opt 1418 0 1416 0 -1418 nt Expr 1419 57465 2159 -1419 nt EndOfStmt 1420 2159 -1420 sem 1431 57489 0 -1421 sem 1422 57574 0 -1422 t "Case" 1423 2165 -1423 nt CaseClauses 1426 57629 2165 -1424 rslv 1425 2165 -1425 t ":" -1427 2165 +1418 nt Expr 1419 57625 2160 +1419 nt EndOfStmt 1420 2160 +1420 sem 1431 57649 0 +1421 sem 1422 57734 0 +1422 t "Case" 1423 2166 +1423 nt CaseClauses 1426 57789 2166 +1424 rslv 1425 2166 +1425 t ":" -1427 2166 1426 opt 1427 0 1424 0 -1427 nt EndOfStmt 1428 2165 -1428 sem 1429 57704 0 -1429 nt Block 1430 57781 2169 -1430 sem -1431 57802 0 +1427 nt EndOfStmt 1428 2166 +1428 sem 1429 57864 0 +1429 nt Block 1430 57941 2170 +1430 sem -1431 57962 0 1431 iter 1432 0 1421 0 -1432 sem 1433 57897 0 -1433 t "End" 1434 2176 -1434 t "Select" 0 2176 -1435 alt 0 1439 1415 2159 -1436 sem 1437 57979 0 -1437 nt OnErrorState 1438 58043 2178 -1438 sem 0 58068 0 +1432 sem 1433 58057 0 +1433 t "End" 1434 2177 +1434 t "Select" 0 2177 +1435 alt 0 1439 1415 2160 +1436 sem 1437 58139 0 +1437 nt OnErrorState 1438 58203 2179 +1438 sem 0 58228 0 1439 alt 0 1443 1436 0 -1440 sem 1441 58108 0 -1441 nt GotoStatemen 1442 58163 2180 -1442 sem 0 58185 0 +1440 sem 1441 58268 0 +1441 nt GotoStatemen 1442 58323 2181 +1442 sem 0 58345 0 1443 alt 0 1447 1440 0 -1444 sem 1445 58222 0 -1445 nt ResumeStatem 1446 58283 2182 -1446 sem 0 58307 0 +1444 sem 1445 58382 0 +1445 nt ResumeStatem 1446 58443 2183 +1446 sem 0 58467 0 1447 alt 0 1457 1444 0 -1448 sem 1449 58428 0 -1449 nt UnaryExpr 1454 58662 2191 -1450 nt AssignmentOp 1451 58699 2193 -1451 nt Expr 1452 58712 2193 -1452 sem -1456 58724 0 -1453 sem -1456 58783 0 -1454 alt 1456 1455 1450 2193 +1448 sem 1449 58588 0 +1449 nt UnaryExpr 1454 58822 2192 +1450 nt AssignmentOp 1451 58859 2194 +1451 nt Expr 1452 58872 2194 +1452 sem -1456 58884 0 +1453 sem -1456 58943 0 +1454 alt 1456 1455 1450 2194 1455 alt 0 0 1453 0 -1456 sem 0 58854 0 +1456 sem 0 59014 0 1457 alt 0 1461 1448 0 -1458 t "Call" 1459 2204 -1459 nt UnaryExpr 1460 59139 2204 -1460 sem 0 59152 0 -1461 alt 0 1485 1458 2204 -1462 t "Using" 1463 2205 -1463 nt Identifier 1464 2205 -1464 sem 1465 59228 0 -1465 t "As" 1479 2208 -1466 t "New" 1467 2210 -1467 nt Qualident 1468 59357 2210 -1468 sem 1473 59374 0 -1469 t "(" 1471 2210 -1470 nt ArgumentList -1472 59427 2210 +1458 t "Call" 1459 2205 +1459 nt UnaryExpr 1460 59299 2205 +1460 sem 0 59312 0 +1461 alt 0 1485 1458 2205 +1462 t "Using" 1463 2206 +1463 nt Identifier 1464 2206 +1464 sem 1465 59388 0 +1465 t "As" 1479 2209 +1466 t "New" 1467 2211 +1467 nt Qualident 1468 59517 2211 +1468 sem 1473 59534 0 +1469 t "(" 1471 2211 +1470 nt ArgumentList -1472 59587 2211 1471 opt 1472 0 1470 0 -1472 t ")" -1474 2210 +1472 t ")" -1474 2211 1473 opt 1474 0 1469 0 -1474 sem -1481 59465 0 -1475 nt Qualident 1476 59656 2215 -1476 t "=" 1477 2215 -1477 nt Expr 1478 59679 2215 -1478 sem -1481 59700 0 -1479 alt 1481 1480 1466 2210 -1480 alt 0 0 1475 2215 -1481 nt Block 1482 59847 2220 -1482 t "End" 1483 2221 -1483 t "Using" 1484 2221 -1484 sem 0 59881 0 -1485 alt 0 0 1462 2205 -1486 nt Qualident 1489 60099 2232 -1487 rslv 1488 2233 -1488 nt ArrayTypeMod -1493 60145 2233 +1474 sem -1481 59625 0 +1475 nt Qualident 1476 59816 2216 +1476 t "=" 1477 2216 +1477 nt Expr 1478 59839 2216 +1478 sem -1481 59860 0 +1479 alt 1481 1480 1466 2211 +1480 alt 0 0 1475 2216 +1481 nt Block 1482 60007 2221 +1482 t "End" 1483 2222 +1483 t "Using" 1484 2222 +1484 sem 0 60041 0 +1485 alt 0 0 1462 2206 +1486 nt Qualident 1489 60259 2233 +1487 rslv 1488 2234 +1488 nt ArrayTypeMod -1493 60305 2234 1489 opt 1493 0 1487 0 -1490 t "As" 1491 2234 -1491 nt TypeName 1492 60185 2234 -1492 sem -1494 60198 0 +1490 t "As" 1491 2235 +1491 nt TypeName 1492 60345 2235 +1492 sem -1494 60358 0 1493 opt 1494 0 1490 0 -1494 sem 0 60303 0 -1495 t "On" 1496 2259 -1496 t "Error" 1504 2259 -1497 rslv 1498 2261 -1498 t "GoTo" 1499 2261 -1499 t "-" 1500 2261 -1500 t LiteralInteg 1501 2261 -1501 sem 0 60970 0 -1502 nt GotoStatemen 1503 61193 2269 -1503 sem 0 61222 0 -1504 alt 0 1505 1497 2261 -1505 alt 0 1509 1502 2269 -1506 t "Resume" 1507 2283 -1507 t "Next" 1508 2283 -1508 sem 0 61548 0 -1509 alt 0 0 1506 2283 -1510 t "GoTo" 1511 2296 -1511 nt LabelName 1512 61780 2296 -1512 sem 0 61799 0 -1513 nt Identifier 1514 2307 -1514 sem 0 61982 0 -1515 t LiteralInteg 1516 2308 -1516 sem 0 62021 0 -1517 alt 0 1518 1513 2307 -1518 alt 0 0 1515 2308 -1519 rslv 1520 2340 -1520 t "Resume" 1521 2341 -1521 t "Next" 1522 2341 -1522 sem 0 62704 0 -1523 t "Resume" 1525 2342 -1524 nt LabelName -1526 62777 2342 +1494 sem 0 60463 0 +1495 t "On" 1496 2260 +1496 t "Error" 1504 2260 +1497 rslv 1498 2262 +1498 t "GoTo" 1499 2262 +1499 t "-" 1500 2262 +1500 t LiteralInteg 1501 2262 +1501 sem 0 61130 0 +1502 nt GotoStatemen 1503 61353 2270 +1503 sem 0 61382 0 +1504 alt 0 1505 1497 2262 +1505 alt 0 1509 1502 2270 +1506 t "Resume" 1507 2284 +1507 t "Next" 1508 2284 +1508 sem 0 61708 0 +1509 alt 0 0 1506 2284 +1510 t "GoTo" 1511 2297 +1511 nt LabelName 1512 61940 2297 +1512 sem 0 61959 0 +1513 nt Identifier 1514 2308 +1514 sem 0 62142 0 +1515 t LiteralInteg 1516 2309 +1516 sem 0 62181 0 +1517 alt 0 1518 1513 2308 +1518 alt 0 0 1515 2309 +1519 rslv 1520 2341 +1520 t "Resume" 1521 2342 +1521 t "Next" 1522 2342 +1522 sem 0 62864 0 +1523 t "Resume" 1525 2343 +1524 nt LabelName -1526 62937 2343 1525 opt 1526 0 1524 0 -1526 sem 0 62793 0 -1527 alt 0 1528 1519 2340 -1528 alt 0 0 1523 2342 -1529 nt CaseClause 1530 62993 2351 -1530 sem 1534 63012 0 -1531 t "," 1532 2352 -1532 nt CaseClause 1533 63063 2352 -1533 sem -1534 63082 0 +1526 sem 0 62953 0 +1527 alt 0 1528 1519 2341 +1528 alt 0 0 1523 2343 +1529 nt CaseClause 1530 63153 2352 +1530 sem 1534 63172 0 +1531 t "," 1532 2353 +1532 nt CaseClause 1533 63223 2353 +1533 sem -1534 63242 0 1534 iter 0 0 1531 0 -1535 t "Else" 1536 2363 -1536 sem 0 63329 0 -1537 t "Is" -1543 2366 +1535 t "Else" 1536 2364 +1536 sem 0 63489 0 +1537 t "Is" -1543 2367 1538 opt 1543 0 1537 0 -1539 t "<" 1540 2368 -1540 sem -1557 63393 0 -1541 t ">" 1542 2369 -1542 sem -1557 63442 0 -1543 alt 1557 1544 1539 2368 -1544 alt 0 1547 1541 2369 -1545 t "<=" 1546 2370 -1546 sem -1557 63495 0 -1547 alt 0 1550 1545 2370 -1548 t ">=" 1549 2371 -1549 sem -1557 63552 0 -1550 alt 0 1553 1548 2371 -1551 t "=" 1552 2372 -1552 sem -1557 63611 0 -1553 alt 0 1556 1551 2372 -1554 t "<>" 1555 2373 -1555 sem -1557 63661 0 -1556 alt 0 0 1554 2373 -1557 nt Expr 1558 63711 2375 -1558 sem 0 63729 0 -1559 alt 0 1560 1535 2363 +1539 t "<" 1540 2369 +1540 sem -1557 63553 0 +1541 t ">" 1542 2370 +1542 sem -1557 63602 0 +1543 alt 1557 1544 1539 2369 +1544 alt 0 1547 1541 2370 +1545 t "<=" 1546 2371 +1546 sem -1557 63655 0 +1547 alt 0 1550 1545 2371 +1548 t ">=" 1549 2372 +1549 sem -1557 63712 0 +1550 alt 0 1553 1548 2372 +1551 t "=" 1552 2373 +1552 sem -1557 63771 0 +1553 alt 0 1556 1551 2373 +1554 t "<>" 1555 2374 +1555 sem -1557 63821 0 +1556 alt 0 0 1554 2374 +1557 nt Expr 1558 63871 2376 +1558 sem 0 63889 0 +1559 alt 0 1560 1535 2364 1560 alt 0 1566 1538 0 -1561 nt Expr 1564 63781 2379 -1562 t "To" 1563 2379 -1563 nt Expr -1565 63803 2379 +1561 nt Expr 1564 63941 2380 +1562 t "To" 1563 2380 +1563 nt Expr -1565 63963 2380 1564 opt 1565 0 1562 0 -1565 sem 0 63824 0 -1566 alt 0 0 1561 2379 -1567 t "While" 1568 2388 -1568 sem 0 63997 0 -1569 t "Until" 1570 2389 -1570 sem 0 64052 0 -1571 alt 0 1572 1567 2388 -1572 alt 0 0 1569 2389 -1573 t "With" 1574 2398 -1574 sem 1575 64236 0 -1575 nt Expr 1576 64272 2399 -1576 nt EndOfStmt 1577 2399 -1577 sem 1578 64300 0 -1578 nt Block 1579 64433 2405 -1579 sem 1580 64456 0 -1580 t "End" 1581 2410 -1581 t "With" 1582 2410 -1582 sem 0 64571 0 -1583 t "Try" 1584 2419 -1584 nt EndOfStmt 1585 2419 -1585 nt Block 1587 64797 2420 -1586 nt CatchClauses -1591 64828 2421 +1565 sem 0 63984 0 +1566 alt 0 0 1561 2380 +1567 t "While" 1568 2389 +1568 sem 0 64157 0 +1569 t "Until" 1570 2390 +1570 sem 0 64212 0 +1571 alt 0 1572 1567 2389 +1572 alt 0 0 1569 2390 +1573 t "With" 1574 2399 +1574 sem 1575 64396 0 +1575 nt Expr 1576 64432 2400 +1576 nt EndOfStmt 1577 2400 +1577 sem 1578 64460 0 +1578 nt Block 1579 64593 2406 +1579 sem 1580 64616 0 +1580 t "End" 1581 2411 +1581 t "With" 1582 2411 +1582 sem 0 64731 0 +1583 t "Try" 1584 2420 +1584 nt EndOfStmt 1585 2420 +1585 nt Block 1587 64957 2421 +1586 nt CatchClauses -1591 64988 2422 1587 opt 1591 0 1586 0 -1588 t "Finally" 1589 2422 -1589 nt EndOfStmt 1590 2422 -1590 nt Block -1592 64876 2422 +1588 t "Finally" 1589 2423 +1589 nt EndOfStmt 1590 2423 +1590 nt Block -1592 65036 2423 1591 opt 1592 0 1588 0 -1592 t "End" 1593 2423 -1593 t "Try" 1594 2423 -1594 sem 0 64917 0 -1595 t "Catch" 1601 2439 -1596 nt Identifier 1597 2440 -1597 sem 1600 65263 0 -1598 t "As" 1599 2440 -1599 nt TypeName -1604 65295 2440 +1592 t "End" 1593 2424 +1593 t "Try" 1594 2424 +1594 sem 0 65077 0 +1595 t "Catch" 1601 2440 +1596 nt Identifier 1597 2441 +1597 sem 1600 65423 0 +1598 t "As" 1599 2441 +1599 nt TypeName -1604 65455 2441 1600 opt -1604 0 1598 0 1601 opt 1604 0 1596 0 -1602 t "When" 1603 2441 -1603 nt Expr -1605 65325 2441 +1602 t "When" 1603 2442 +1603 nt Expr -1605 65485 2442 1604 opt 1605 0 1602 0 -1605 nt EndOfStmt 1606 2442 -1606 nt Block 1607 65359 2443 -1607 sem -1608 65380 0 +1605 nt EndOfStmt 1606 2443 +1606 nt Block 1607 65519 2444 +1607 sem -1608 65540 0 1608 iter 0 0 1595 0 -1609 nt Identifier 1610 2455 -1610 sem 1615 65576 0 -1611 rslv 1612 2456 -1612 t "." 1613 2456 -1613 nt IdentifierOr 1614 65662 2456 -1614 sem -1615 65675 0 +1609 nt Identifier 1610 2456 +1610 sem 1615 65736 0 +1611 rslv 1612 2457 +1612 t "." 1613 2457 +1613 nt IdentifierOr 1614 65822 2457 +1614 sem -1615 65835 0 1615 iter 1616 0 1611 0 -1616 sem 0 65749 0 -1617 t ident 0 2463 -1618 t "Text" 0 2464 -1619 alt 0 1620 1617 2463 -1620 alt 0 1622 1618 2464 -1621 t "Binary" 0 2465 -1622 alt 0 1624 1621 2465 -1623 t "Compare" 0 2466 -1624 alt 0 0 1623 2466 -1625 nt Identifier 1626 2475 -1626 sem 0 66042 0 -1627 t "AddHandler" 1628 2476 -1628 sem 0 66080 0 -1629 alt 0 1630 1625 2475 -1630 alt 0 1633 1627 2476 -1631 t "AddressOf" 1632 2477 -1632 sem 0 66117 0 -1633 alt 0 1636 1631 2477 -1634 t "Alias" 1635 2478 -1635 sem 0 66151 0 -1636 alt 0 1639 1634 2478 -1637 t "And" 1638 2479 -1638 sem 0 66184 0 -1639 alt 0 1642 1637 2479 -1640 t "AndAlso" 1641 2480 -1641 sem 0 66220 0 -1642 alt 0 1645 1640 2480 -1643 t "Ansi" 1644 2481 -1644 sem 0 66253 0 -1645 alt 0 1648 1643 2481 -1646 t "As" 1647 2482 -1647 sem 0 66285 0 -1648 alt 0 1651 1646 2482 -1649 t "Assembly" 1650 2483 -1650 sem 0 66321 0 -1651 alt 0 1654 1649 2483 -1652 t "Auto" 1653 2484 -1653 sem 0 66354 0 -1654 alt 0 1657 1652 2484 -1655 t "Boolean" 1656 2485 -1656 sem 0 66390 0 -1657 alt 0 1660 1655 2485 -1658 t "ByRef" 1659 2486 -1659 sem 0 66424 0 -1660 alt 0 1663 1658 2486 -1661 t "Byte" 1662 2487 -1662 sem 0 66457 0 -1663 alt 0 1666 1661 2487 -1664 t "ByVal" 1665 2488 -1665 sem 0 66491 0 -1666 alt 0 1669 1664 2488 -1667 t "Call" 1668 2489 -1668 sem 0 66524 0 -1669 alt 0 1672 1667 2489 -1670 t "Case" 1671 2490 -1671 sem 0 66557 0 -1672 alt 0 1675 1670 2490 -1673 t "Catch" 1674 2491 -1674 sem 0 66591 0 -1675 alt 0 1678 1673 2491 -1676 t "CBool" 1677 2492 -1677 sem 0 66625 0 -1678 alt 0 1681 1676 2492 -1679 t "CByte" 1680 2493 -1680 sem 0 66659 0 -1681 alt 0 1684 1679 2493 -1682 t "CChar" 1683 2494 -1683 sem 0 66693 0 -1684 alt 0 1687 1682 2494 -1685 t "CDate" 1686 2495 -1686 sem 0 66727 0 -1687 alt 0 1690 1685 2495 -1688 t "CDbl" 1689 2496 -1689 sem 0 66760 0 -1690 alt 0 1693 1688 2496 -1691 t "CDec" 1692 2497 -1692 sem 0 66793 0 -1693 alt 0 1696 1691 2497 -1694 t "Char" 1695 2498 -1695 sem 0 66826 0 -1696 alt 0 1699 1694 2498 -1697 t "CInt" 1698 2499 -1698 sem 0 66859 0 -1699 alt 0 1702 1697 2499 -1700 t "Class" 1701 2500 -1701 sem 0 66893 0 -1702 alt 0 1705 1700 2500 -1703 t "CLng" 1704 2501 -1704 sem 0 66926 0 -1705 alt 0 1708 1703 2501 -1706 t "CObj" 1707 2502 -1707 sem 0 66959 0 -1708 alt 0 1711 1706 2502 -1709 t "Const" 1710 2503 -1710 sem 0 66993 0 -1711 alt 0 1714 1709 2503 -1712 t "CShort" 1713 2504 -1713 sem 0 67028 0 -1714 alt 0 1717 1712 2504 -1715 t "CSng" 1716 2505 -1716 sem 0 67061 0 -1717 alt 0 1720 1715 2505 -1718 t "CStr" 1719 2506 -1719 sem 0 67094 0 -1720 alt 0 1723 1718 2506 -1721 t "CType" 1722 2507 -1722 sem 0 67128 0 -1723 alt 0 1726 1721 2507 -1724 t "Date" 1725 2508 -1725 sem 0 67161 0 -1726 alt 0 1729 1724 2508 -1727 t "Decimal" 1728 2509 -1728 sem 0 67197 0 -1729 alt 0 1732 1727 2509 -1730 t "Declare" 1731 2510 -1731 sem 0 67233 0 -1732 alt 0 1735 1730 2510 -1733 t "Default" 1734 2511 -1734 sem 0 67269 0 -1735 alt 0 1738 1733 2511 -1736 t "Delegate" 1737 2512 -1737 sem 0 67305 0 -1738 alt 0 1741 1736 2512 -1739 t "Dim" 1740 2513 -1740 sem 0 67338 0 -1741 alt 0 1744 1739 2513 -1742 t "DirectCast" 1743 2514 -1743 sem 0 67376 0 -1744 alt 0 1747 1742 2514 -1745 t "Do" 1746 2515 -1746 sem 0 67408 0 -1747 alt 0 1750 1745 2515 -1748 t "Double" 1749 2516 -1749 sem 0 67443 0 -1750 alt 0 1753 1748 2516 -1751 t "Each" 1752 2517 -1752 sem 0 67476 0 -1753 alt 0 1756 1751 2517 -1754 t "Else" 1755 2518 -1755 sem 0 67509 0 -1756 alt 0 1759 1754 2518 -1757 t "ElseIf" 1758 2519 -1758 sem 0 67544 0 -1759 alt 0 1762 1757 2519 -1760 t "End" 1761 2520 -1761 sem 0 67577 0 -1762 alt 0 1765 1760 2520 -1763 t "EndIf" 1764 2521 -1764 sem 0 67611 0 -1765 alt 0 1768 1763 2521 -1766 t "Enum" 1767 2522 -1767 sem 0 67644 0 -1768 alt 0 1771 1766 2522 -1769 t "Erase" 1770 2523 -1770 sem 0 67678 0 -1771 alt 0 1774 1769 2523 -1772 t "Error" 1773 2524 -1773 sem 0 67712 0 -1774 alt 0 1777 1772 2524 -1775 t "Event" 1776 2525 -1776 sem 0 67746 0 -1777 alt 0 1780 1775 2525 -1778 t "Exit" 1779 2526 -1779 sem 0 67779 0 -1780 alt 0 1783 1778 2526 -1781 t "Explicit" 1782 2527 -1782 sem 0 67821 0 -1783 alt 0 1786 1781 2527 -1784 t "False" 1785 2528 -1785 sem 0 67855 0 -1786 alt 0 1789 1784 2528 -1787 t "Finally" 1788 2529 -1788 sem 0 67891 0 -1789 alt 0 1792 1787 2529 -1790 t "For" 1791 2530 -1791 sem 0 67924 0 -1792 alt 0 1795 1790 2530 -1793 t "Friend" 1794 2531 -1794 sem 0 67959 0 -1795 alt 0 1798 1793 2531 -1796 t "Function" 1797 2532 -1797 sem 0 67995 0 -1798 alt 0 1801 1796 2532 -1799 t "Get" 1800 2533 -1800 sem 0 68028 0 -1801 alt 0 1804 1799 2533 -1802 t "GetType" 1803 2534 -1803 sem 0 68064 0 -1804 alt 0 1807 1802 2534 -1805 t "GoSub" 1806 2535 -1806 sem 0 68098 0 -1807 alt 0 1810 1805 2535 -1808 t "GoTo" 1809 2536 -1809 sem 0 68131 0 -1810 alt 0 1813 1808 2536 -1811 t "Handles" 1812 2537 -1812 sem 0 68167 0 -1813 alt 0 1816 1811 2537 -1814 t "If" 1815 2538 -1815 sem 0 68199 0 -1816 alt 0 1819 1814 2538 -1817 t "Implements" 1818 2539 -1818 sem 0 68237 0 -1819 alt 0 1822 1817 2539 -1820 t "Imports" 1821 2540 -1821 sem 0 68273 0 -1822 alt 0 1825 1820 2540 -1823 t "In" 1824 2541 -1824 sem 0 68305 0 -1825 alt 0 1828 1823 2541 -1826 t "Inherits" 1827 2542 -1827 sem 0 68341 0 -1828 alt 0 1831 1826 2542 -1829 t "Integer" 1830 2543 -1830 sem 0 68377 0 -1831 alt 0 1834 1829 2543 -1832 t "Interface" 1833 2544 -1833 sem 0 68414 0 -1834 alt 0 1837 1832 2544 -1835 t "Is" 1836 2545 -1836 sem 0 68446 0 -1837 alt 0 1840 1835 2545 -1838 t "Let" 1839 2546 -1839 sem 0 68479 0 -1840 alt 0 1843 1838 2546 -1841 t "Lib" 1842 2547 -1842 sem 0 68512 0 -1843 alt 0 1846 1841 2547 -1844 t "Like" 1845 2548 -1845 sem 0 68545 0 -1846 alt 0 1849 1844 2548 -1847 t "Long" 1848 2549 -1848 sem 0 68578 0 -1849 alt 0 1852 1847 2549 -1850 t "Loop" 1851 2550 -1851 sem 0 68611 0 -1852 alt 0 1855 1850 2550 -1853 t "Me" 1854 2551 -1854 sem 0 68643 0 -1855 alt 0 1858 1853 2551 -1856 t "Mod" 1857 2552 -1857 sem 0 68676 0 -1858 alt 0 1861 1856 2552 -1859 t "Module" 1860 2553 -1860 sem 0 68711 0 -1861 alt 0 1864 1859 2553 -1862 t "MustInherit 1863 2554 -1863 sem 0 68750 0 -1864 alt 0 1867 1862 2554 -1865 t "MustOverrid 1866 2555 -1866 sem 0 68789 0 -1867 alt 0 1870 1865 2555 -1868 t "MyBase" 1869 2556 -1869 sem 0 68824 0 -1870 alt 0 1873 1868 2556 -1871 t "MyClass" 1872 2557 -1872 sem 0 68860 0 -1873 alt 0 1876 1871 2557 -1874 t "Namespace" 1875 2558 -1875 sem 0 68897 0 -1876 alt 0 1879 1874 2558 -1877 t "New" 1878 2559 -1878 sem 0 68930 0 -1879 alt 0 1882 1877 2559 -1880 t "Next" 1881 2560 -1881 sem 0 68963 0 -1882 alt 0 1885 1880 2560 -1883 t "Not" 1884 2561 -1884 sem 0 68996 0 -1885 alt 0 1888 1883 2561 -1886 t "Nothing" 1887 2562 -1887 sem 0 69032 0 -1888 alt 0 1891 1886 2562 -1889 t "NotInherita 1890 2563 -1890 sem 0 69073 0 -1891 alt 0 1894 1889 2563 -1892 t "NotOverrida 1893 2564 -1893 sem 0 69114 0 -1894 alt 0 1897 1892 2564 -1895 t "Object" 1896 2565 -1896 sem 0 69149 0 -1897 alt 0 1900 1895 2565 -1898 t "On" 1899 2566 -1899 sem 0 69181 0 -1900 alt 0 1903 1898 2566 -1901 t "Option" 1902 2567 -1902 sem 0 69216 0 -1903 alt 0 1906 1901 2567 -1904 t "Optional" 1905 2568 -1905 sem 0 69252 0 -1906 alt 0 1909 1904 2568 -1907 t "Or" 1908 2569 -1908 sem 0 69284 0 -1909 alt 0 1912 1907 2569 -1910 t "OrElse" 1911 2570 -1911 sem 0 69319 0 -1912 alt 0 1915 1910 2570 -1913 t "Overloads" 1914 2571 -1914 sem 0 69356 0 -1915 alt 0 1918 1913 2571 -1916 t "Overridable 1917 2572 -1917 sem 0 69395 0 -1918 alt 0 1921 1916 2572 -1919 t "Overrides" 1920 2573 -1920 sem 0 69432 0 -1921 alt 0 1924 1919 2573 -1922 t "ParamArray" 1923 2574 -1923 sem 0 69470 0 -1924 alt 0 1927 1922 2574 -1925 t "Preserve" 1926 2575 -1926 sem 0 69506 0 -1927 alt 0 1930 1925 2575 -1928 t "Private" 1929 2576 -1929 sem 0 69542 0 -1930 alt 0 1933 1928 2576 -1931 t "Property" 1932 2577 -1932 sem 0 69578 0 -1933 alt 0 1936 1931 2577 -1934 t "Protected" 1935 2578 -1935 sem 0 69615 0 -1936 alt 0 1939 1934 2578 -1937 t "Public" 1938 2579 -1938 sem 0 69650 0 -1939 alt 0 1942 1937 2579 -1940 t "RaiseEvent" 1941 2580 -1941 sem 0 69688 0 -1942 alt 0 1945 1940 2580 -1943 t "ReadOnly" 1944 2581 -1944 sem 0 69724 0 -1945 alt 0 1948 1943 2581 -1946 t "ReDim" 1947 2582 -1947 sem 0 69758 0 -1948 alt 0 1951 1946 2582 -1949 t "RemoveHandl 1950 2583 -1950 sem 0 69798 0 -1951 alt 0 1954 1949 2583 -1952 t "Resume" 1953 2584 -1953 sem 0 69833 0 -1954 alt 0 1957 1952 2584 -1955 t "Return" 1956 2585 -1956 sem 0 69868 0 -1957 alt 0 1960 1955 2585 -1958 t "Select" 1959 2586 -1959 sem 0 69903 0 -1960 alt 0 1963 1958 2586 -1961 t "Set" 1962 2587 -1962 sem 0 69936 0 -1963 alt 0 1966 1961 2587 -1964 t "Shadows" 1965 2588 -1965 sem 0 69972 0 -1966 alt 0 1969 1964 2588 -1967 t "Shared" 1968 2589 -1968 sem 0 70007 0 -1969 alt 0 1972 1967 2589 -1970 t "Short" 1971 2590 -1971 sem 0 70041 0 -1972 alt 0 1975 1970 2590 -1973 t "Single" 1974 2591 -1974 sem 0 70076 0 -1975 alt 0 1978 1973 2591 -1976 t "Static" 1977 2592 -1977 sem 0 70111 0 -1978 alt 0 1981 1976 2592 -1979 t "Step" 1980 2593 -1980 sem 0 70144 0 -1981 alt 0 1984 1979 2593 -1982 t "Stop" 1983 2594 -1983 sem 0 70177 0 -1984 alt 0 1987 1982 2594 -1985 t "String" 1986 2595 -1986 sem 0 70212 0 -1987 alt 0 1990 1985 2595 -1988 t "Structure" 1989 2596 -1989 sem 0 70249 0 -1990 alt 0 1993 1988 2596 -1991 t "Sub" 1992 2597 -1992 sem 0 70282 0 -1993 alt 0 1996 1991 2597 -1994 t "SyncLock" 1995 2598 -1995 sem 0 70318 0 -1996 alt 0 1999 1994 2598 -1997 t "Then" 1998 2599 -1998 sem 0 70351 0 -1999 alt 0 2002 1997 2599 -2000 t "Throw" 2001 2600 -2001 sem 0 70385 0 -2002 alt 0 2005 2000 2600 -2003 t "To" 2004 2601 -2004 sem 0 70417 0 -2005 alt 0 2008 2003 2601 -2006 t "True" 2007 2602 -2007 sem 0 70450 0 -2008 alt 0 2011 2006 2602 -2009 t "Try" 2010 2603 -2010 sem 0 70483 0 -2011 alt 0 2014 2009 2603 -2012 t "TypeOf" 2013 2604 -2013 sem 0 70518 0 -2014 alt 0 2017 2012 2604 -2015 t "Unicode" 2016 2605 -2016 sem 0 70554 0 -2017 alt 0 2020 2015 2605 -2018 t "Until" 2019 2606 -2019 sem 0 70588 0 -2020 alt 0 2023 2018 2606 -2021 t "Variant" 2022 2607 -2022 sem 0 70624 0 -2023 alt 0 2026 2021 2607 -2024 t "Wend" 2025 2608 -2025 sem 0 70657 0 -2026 alt 0 2029 2024 2608 -2027 t "When" 2028 2609 -2028 sem 0 70690 0 -2029 alt 0 2032 2027 2609 -2030 t "While" 2031 2610 -2031 sem 0 70724 0 -2032 alt 0 2035 2030 2610 -2033 t "With" 2034 2611 -2034 sem 0 70757 0 -2035 alt 0 2038 2033 2611 -2036 t "WithEvents" 2037 2612 -2037 sem 0 70795 0 -2038 alt 0 2041 2036 2612 -2039 t "WriteOnly" 2040 2613 -2040 sem 0 70832 0 -2041 alt 0 2044 2039 2613 -2042 t "Xor" 2043 2614 -2043 sem 0 70865 0 -2044 alt 0 2047 2042 2614 -2045 t "Continue" 2046 2615 -2046 sem 0 70901 0 -2047 alt 0 2050 2045 2615 -2048 t "Operator" 2049 2616 -2049 sem 0 70937 0 -2050 alt 0 2053 2048 2616 -2051 t "Using" 2052 2617 -2052 sem 0 70971 0 -2053 alt 0 2056 2051 2617 -2054 t "IsNot" 2055 2618 -2055 sem 0 71005 0 -2056 alt 0 2059 2054 2618 -2057 t "SByte" 2058 2619 -2058 sem 0 71039 0 -2059 alt 0 2062 2057 2619 -2060 t "UInteger" 2061 2620 -2061 sem 0 71075 0 -2062 alt 0 2065 2060 2620 -2063 t "ULong" 2064 2621 -2064 sem 0 71109 0 -2065 alt 0 2068 2063 2621 -2066 t "UShort" 2067 2622 -2067 sem 0 71144 0 -2068 alt 0 2071 2066 2622 -2069 t "Of" 2070 2623 -2070 sem 0 71176 0 -2071 alt 0 2074 2069 2623 -2072 t "Narrowing" 2073 2624 -2073 sem 0 71213 0 -2074 alt 0 2077 2072 2624 -2075 t "Widening" 2076 2625 -2076 sem 0 71249 0 -2077 alt 0 2080 2075 2625 -2078 t "Partial" 2079 2626 -2079 sem 0 71285 0 -2080 alt 0 0 2078 2626 -2081 t "Boolean" 2082 2633 -2082 sem 0 71404 0 -2083 t "Date" 2084 2634 -2084 sem 0 71440 0 -2085 alt 0 2086 2081 2633 -2086 alt 0 2089 2083 2634 -2087 t "Char" 2088 2635 -2088 sem 0 71473 0 -2089 alt 0 2092 2087 2635 -2090 t "String" 2091 2636 -2091 sem 0 71508 0 -2092 alt 0 2095 2090 2636 -2093 t "Decimal" 2094 2637 -2094 sem 0 71546 0 -2095 alt 0 2098 2093 2637 -2096 t "Byte" 2097 2638 -2097 sem 0 71582 0 -2098 alt 0 2101 2096 2638 -2099 t "Short" 2100 2639 -2100 sem 0 71616 0 -2101 alt 0 2104 2099 2639 -2102 t "Integer" 2103 2640 -2103 sem 0 71653 0 -2104 alt 0 2107 2102 2640 -2105 t "Long" 2106 2641 -2106 sem 0 71689 0 -2107 alt 0 2110 2105 2641 -2108 t "Single" 2109 2642 -2109 sem 0 71724 0 -2110 alt 0 2113 2108 2642 -2111 t "Double" 2112 2643 -2112 sem 0 71761 0 -2113 alt 0 2116 2111 2643 -2114 t "UInteger" 2115 2644 -2115 sem 0 71799 0 -2116 alt 0 2119 2114 2644 -2117 t "ULong" 2118 2645 -2118 sem 0 71837 0 -2119 alt 0 2122 2117 2645 -2120 t "UShort" 2121 2646 -2121 sem 0 71873 0 -2122 alt 0 2125 2120 2646 -2123 t "SByte" 2124 2647 -2124 sem 0 71909 0 -2125 alt 0 0 2123 2647 -2126 t "ByVal" 2127 2652 -2127 sem 0 71991 0 -2128 t "ByRef" 2129 2653 -2129 sem 0 72036 0 -2130 alt 0 2131 2126 2652 -2131 alt 0 2134 2128 2653 -2132 t "Optional" 2133 2654 -2133 sem 0 72084 0 -2134 alt 0 2137 2132 2654 -2135 t "ParamArray" 2136 2655 -2136 sem 0 72139 0 -2137 alt 0 0 2135 2655 -2138 t "Public" 2139 2659 -2139 sem 0 72222 0 -2140 t "Protected" 2141 2660 -2141 sem 0 72269 0 -2142 alt 0 2143 2138 2659 -2143 alt 0 2146 2140 2660 -2144 t "Friend" 2145 2661 -2145 sem 0 72317 0 -2146 alt 0 2149 2144 2661 -2147 t "Private" 2148 2662 -2148 sem 0 72365 0 -2149 alt 0 2152 2147 2662 -2150 t "Shared" 2151 2663 -2151 sem 0 72411 0 -2152 alt 0 2155 2150 2663 -2153 t "Shadows" 2154 2664 -2154 sem 0 72457 0 -2155 alt 0 2158 2153 2664 -2156 t "MustInherit 2157 2665 -2157 sem 0 72503 0 -2158 alt 0 2161 2156 2665 -2159 t "NotInherita 2160 2666 -2160 sem 0 72556 0 -2161 alt 0 0 2159 2666 -2162 t "MustInherit 2163 2670 -2163 sem 0 72639 0 -2164 t "Default" 2165 2671 -2165 sem 0 72684 0 -2166 alt 0 2167 2162 2670 -2167 alt 0 2170 2164 2671 -2168 t "Friend" 2169 2672 -2169 sem 0 72727 0 -2170 alt 0 2173 2168 2672 -2171 t "Shadows" 2172 2673 -2172 sem 0 72772 0 -2173 alt 0 2176 2171 2673 -2174 t "Overrides" 2175 2674 -2175 sem 0 72813 0 -2176 alt 0 2179 2174 2674 -2177 t "MustOverrid 2178 2675 -2178 sem 0 72862 0 -2179 alt 0 2182 2177 2675 -2180 t "Private" 2181 2676 -2181 sem 0 72907 0 -2182 alt 0 2185 2180 2676 -2183 t "Protected" 2184 2677 -2184 sem 0 72952 0 -2185 alt 0 2188 2183 2677 -2186 t "Public" 2187 2678 -2187 sem 0 72997 0 -2188 alt 0 2191 2186 2678 -2189 t "NotInherita 2190 2679 -2190 sem 0 73045 0 -2191 alt 0 2194 2189 2679 -2192 t "NotOverrida 2193 2680 -2193 sem 0 73093 0 -2194 alt 0 2197 2192 2680 -2195 t "Shared" 2196 2681 -2196 sem 0 73135 0 -2197 alt 0 2200 2195 2681 -2198 t "Overridable 2199 2682 -2199 sem 0 73181 0 -2200 alt 0 2203 2198 2682 -2201 t "Overloads" 2202 2683 -2202 sem 0 73226 0 -2203 alt 0 2206 2201 2683 -2204 t "ReadOnly" 2205 2684 -2205 sem 0 73306 0 -2206 alt 0 2209 2204 2684 -2207 t "WriteOnly" 2208 2685 -2208 sem 0 73362 0 -2209 alt 0 2212 2207 2685 -2210 t "WithEvents" 2211 2686 -2211 sem 0 73385 0 -2212 alt 0 2215 2210 2686 -2213 t "Dim" 2214 2687 -2214 sem 0 73430 0 -2215 alt 0 0 2213 2687 +1616 sem 0 65909 0 +1617 t ident 0 2464 +1618 t "Text" 0 2465 +1619 alt 0 1620 1617 2464 +1620 alt 0 1622 1618 2465 +1621 t "Binary" 0 2466 +1622 alt 0 1624 1621 2466 +1623 t "Compare" 0 2467 +1624 alt 0 0 1623 2467 +1625 nt Identifier 1626 2476 +1626 sem 0 66202 0 +1627 t "AddHandler" 1628 2477 +1628 sem 0 66240 0 +1629 alt 0 1630 1625 2476 +1630 alt 0 1633 1627 2477 +1631 t "AddressOf" 1632 2478 +1632 sem 0 66277 0 +1633 alt 0 1636 1631 2478 +1634 t "Alias" 1635 2479 +1635 sem 0 66311 0 +1636 alt 0 1639 1634 2479 +1637 t "And" 1638 2480 +1638 sem 0 66344 0 +1639 alt 0 1642 1637 2480 +1640 t "AndAlso" 1641 2481 +1641 sem 0 66380 0 +1642 alt 0 1645 1640 2481 +1643 t "Ansi" 1644 2482 +1644 sem 0 66413 0 +1645 alt 0 1648 1643 2482 +1646 t "As" 1647 2483 +1647 sem 0 66445 0 +1648 alt 0 1651 1646 2483 +1649 t "Assembly" 1650 2484 +1650 sem 0 66481 0 +1651 alt 0 1654 1649 2484 +1652 t "Auto" 1653 2485 +1653 sem 0 66514 0 +1654 alt 0 1657 1652 2485 +1655 t "Boolean" 1656 2486 +1656 sem 0 66550 0 +1657 alt 0 1660 1655 2486 +1658 t "ByRef" 1659 2487 +1659 sem 0 66584 0 +1660 alt 0 1663 1658 2487 +1661 t "Byte" 1662 2488 +1662 sem 0 66617 0 +1663 alt 0 1666 1661 2488 +1664 t "ByVal" 1665 2489 +1665 sem 0 66651 0 +1666 alt 0 1669 1664 2489 +1667 t "Call" 1668 2490 +1668 sem 0 66684 0 +1669 alt 0 1672 1667 2490 +1670 t "Case" 1671 2491 +1671 sem 0 66717 0 +1672 alt 0 1675 1670 2491 +1673 t "Catch" 1674 2492 +1674 sem 0 66751 0 +1675 alt 0 1678 1673 2492 +1676 t "CBool" 1677 2493 +1677 sem 0 66785 0 +1678 alt 0 1681 1676 2493 +1679 t "CByte" 1680 2494 +1680 sem 0 66819 0 +1681 alt 0 1684 1679 2494 +1682 t "CChar" 1683 2495 +1683 sem 0 66853 0 +1684 alt 0 1687 1682 2495 +1685 t "CDate" 1686 2496 +1686 sem 0 66887 0 +1687 alt 0 1690 1685 2496 +1688 t "CDbl" 1689 2497 +1689 sem 0 66920 0 +1690 alt 0 1693 1688 2497 +1691 t "CDec" 1692 2498 +1692 sem 0 66953 0 +1693 alt 0 1696 1691 2498 +1694 t "Char" 1695 2499 +1695 sem 0 66986 0 +1696 alt 0 1699 1694 2499 +1697 t "CInt" 1698 2500 +1698 sem 0 67019 0 +1699 alt 0 1702 1697 2500 +1700 t "Class" 1701 2501 +1701 sem 0 67053 0 +1702 alt 0 1705 1700 2501 +1703 t "CLng" 1704 2502 +1704 sem 0 67086 0 +1705 alt 0 1708 1703 2502 +1706 t "CObj" 1707 2503 +1707 sem 0 67119 0 +1708 alt 0 1711 1706 2503 +1709 t "Const" 1710 2504 +1710 sem 0 67153 0 +1711 alt 0 1714 1709 2504 +1712 t "CShort" 1713 2505 +1713 sem 0 67188 0 +1714 alt 0 1717 1712 2505 +1715 t "CSng" 1716 2506 +1716 sem 0 67221 0 +1717 alt 0 1720 1715 2506 +1718 t "CStr" 1719 2507 +1719 sem 0 67254 0 +1720 alt 0 1723 1718 2507 +1721 t "CType" 1722 2508 +1722 sem 0 67288 0 +1723 alt 0 1726 1721 2508 +1724 t "Date" 1725 2509 +1725 sem 0 67321 0 +1726 alt 0 1729 1724 2509 +1727 t "Decimal" 1728 2510 +1728 sem 0 67357 0 +1729 alt 0 1732 1727 2510 +1730 t "Declare" 1731 2511 +1731 sem 0 67393 0 +1732 alt 0 1735 1730 2511 +1733 t "Default" 1734 2512 +1734 sem 0 67429 0 +1735 alt 0 1738 1733 2512 +1736 t "Delegate" 1737 2513 +1737 sem 0 67465 0 +1738 alt 0 1741 1736 2513 +1739 t "Dim" 1740 2514 +1740 sem 0 67498 0 +1741 alt 0 1744 1739 2514 +1742 t "DirectCast" 1743 2515 +1743 sem 0 67536 0 +1744 alt 0 1747 1742 2515 +1745 t "Do" 1746 2516 +1746 sem 0 67568 0 +1747 alt 0 1750 1745 2516 +1748 t "Double" 1749 2517 +1749 sem 0 67603 0 +1750 alt 0 1753 1748 2517 +1751 t "Each" 1752 2518 +1752 sem 0 67636 0 +1753 alt 0 1756 1751 2518 +1754 t "Else" 1755 2519 +1755 sem 0 67669 0 +1756 alt 0 1759 1754 2519 +1757 t "ElseIf" 1758 2520 +1758 sem 0 67704 0 +1759 alt 0 1762 1757 2520 +1760 t "End" 1761 2521 +1761 sem 0 67737 0 +1762 alt 0 1765 1760 2521 +1763 t "EndIf" 1764 2522 +1764 sem 0 67771 0 +1765 alt 0 1768 1763 2522 +1766 t "Enum" 1767 2523 +1767 sem 0 67804 0 +1768 alt 0 1771 1766 2523 +1769 t "Erase" 1770 2524 +1770 sem 0 67838 0 +1771 alt 0 1774 1769 2524 +1772 t "Error" 1773 2525 +1773 sem 0 67872 0 +1774 alt 0 1777 1772 2525 +1775 t "Event" 1776 2526 +1776 sem 0 67906 0 +1777 alt 0 1780 1775 2526 +1778 t "Exit" 1779 2527 +1779 sem 0 67939 0 +1780 alt 0 1783 1778 2527 +1781 t "Explicit" 1782 2528 +1782 sem 0 67981 0 +1783 alt 0 1786 1781 2528 +1784 t "False" 1785 2529 +1785 sem 0 68015 0 +1786 alt 0 1789 1784 2529 +1787 t "Finally" 1788 2530 +1788 sem 0 68051 0 +1789 alt 0 1792 1787 2530 +1790 t "For" 1791 2531 +1791 sem 0 68084 0 +1792 alt 0 1795 1790 2531 +1793 t "Friend" 1794 2532 +1794 sem 0 68119 0 +1795 alt 0 1798 1793 2532 +1796 t "Function" 1797 2533 +1797 sem 0 68155 0 +1798 alt 0 1801 1796 2533 +1799 t "Get" 1800 2534 +1800 sem 0 68188 0 +1801 alt 0 1804 1799 2534 +1802 t "GetType" 1803 2535 +1803 sem 0 68224 0 +1804 alt 0 1807 1802 2535 +1805 t "GoSub" 1806 2536 +1806 sem 0 68258 0 +1807 alt 0 1810 1805 2536 +1808 t "GoTo" 1809 2537 +1809 sem 0 68291 0 +1810 alt 0 1813 1808 2537 +1811 t "Handles" 1812 2538 +1812 sem 0 68327 0 +1813 alt 0 1816 1811 2538 +1814 t "If" 1815 2539 +1815 sem 0 68359 0 +1816 alt 0 1819 1814 2539 +1817 t "Implements" 1818 2540 +1818 sem 0 68397 0 +1819 alt 0 1822 1817 2540 +1820 t "Imports" 1821 2541 +1821 sem 0 68433 0 +1822 alt 0 1825 1820 2541 +1823 t "In" 1824 2542 +1824 sem 0 68465 0 +1825 alt 0 1828 1823 2542 +1826 t "Inherits" 1827 2543 +1827 sem 0 68501 0 +1828 alt 0 1831 1826 2543 +1829 t "Integer" 1830 2544 +1830 sem 0 68537 0 +1831 alt 0 1834 1829 2544 +1832 t "Interface" 1833 2545 +1833 sem 0 68574 0 +1834 alt 0 1837 1832 2545 +1835 t "Is" 1836 2546 +1836 sem 0 68606 0 +1837 alt 0 1840 1835 2546 +1838 t "Let" 1839 2547 +1839 sem 0 68639 0 +1840 alt 0 1843 1838 2547 +1841 t "Lib" 1842 2548 +1842 sem 0 68672 0 +1843 alt 0 1846 1841 2548 +1844 t "Like" 1845 2549 +1845 sem 0 68705 0 +1846 alt 0 1849 1844 2549 +1847 t "Long" 1848 2550 +1848 sem 0 68738 0 +1849 alt 0 1852 1847 2550 +1850 t "Loop" 1851 2551 +1851 sem 0 68771 0 +1852 alt 0 1855 1850 2551 +1853 t "Me" 1854 2552 +1854 sem 0 68803 0 +1855 alt 0 1858 1853 2552 +1856 t "Mod" 1857 2553 +1857 sem 0 68836 0 +1858 alt 0 1861 1856 2553 +1859 t "Module" 1860 2554 +1860 sem 0 68871 0 +1861 alt 0 1864 1859 2554 +1862 t "MustInherit 1863 2555 +1863 sem 0 68910 0 +1864 alt 0 1867 1862 2555 +1865 t "MustOverrid 1866 2556 +1866 sem 0 68949 0 +1867 alt 0 1870 1865 2556 +1868 t "MyBase" 1869 2557 +1869 sem 0 68984 0 +1870 alt 0 1873 1868 2557 +1871 t "MyClass" 1872 2558 +1872 sem 0 69020 0 +1873 alt 0 1876 1871 2558 +1874 t "Namespace" 1875 2559 +1875 sem 0 69057 0 +1876 alt 0 1879 1874 2559 +1877 t "New" 1878 2560 +1878 sem 0 69090 0 +1879 alt 0 1882 1877 2560 +1880 t "Next" 1881 2561 +1881 sem 0 69123 0 +1882 alt 0 1885 1880 2561 +1883 t "Not" 1884 2562 +1884 sem 0 69156 0 +1885 alt 0 1888 1883 2562 +1886 t "Nothing" 1887 2563 +1887 sem 0 69192 0 +1888 alt 0 1891 1886 2563 +1889 t "NotInherita 1890 2564 +1890 sem 0 69233 0 +1891 alt 0 1894 1889 2564 +1892 t "NotOverrida 1893 2565 +1893 sem 0 69274 0 +1894 alt 0 1897 1892 2565 +1895 t "Object" 1896 2566 +1896 sem 0 69309 0 +1897 alt 0 1900 1895 2566 +1898 t "On" 1899 2567 +1899 sem 0 69341 0 +1900 alt 0 1903 1898 2567 +1901 t "Option" 1902 2568 +1902 sem 0 69376 0 +1903 alt 0 1906 1901 2568 +1904 t "Optional" 1905 2569 +1905 sem 0 69412 0 +1906 alt 0 1909 1904 2569 +1907 t "Or" 1908 2570 +1908 sem 0 69444 0 +1909 alt 0 1912 1907 2570 +1910 t "OrElse" 1911 2571 +1911 sem 0 69479 0 +1912 alt 0 1915 1910 2571 +1913 t "Overloads" 1914 2572 +1914 sem 0 69516 0 +1915 alt 0 1918 1913 2572 +1916 t "Overridable 1917 2573 +1917 sem 0 69555 0 +1918 alt 0 1921 1916 2573 +1919 t "Overrides" 1920 2574 +1920 sem 0 69592 0 +1921 alt 0 1924 1919 2574 +1922 t "ParamArray" 1923 2575 +1923 sem 0 69630 0 +1924 alt 0 1927 1922 2575 +1925 t "Preserve" 1926 2576 +1926 sem 0 69666 0 +1927 alt 0 1930 1925 2576 +1928 t "Private" 1929 2577 +1929 sem 0 69702 0 +1930 alt 0 1933 1928 2577 +1931 t "Property" 1932 2578 +1932 sem 0 69738 0 +1933 alt 0 1936 1931 2578 +1934 t "Protected" 1935 2579 +1935 sem 0 69775 0 +1936 alt 0 1939 1934 2579 +1937 t "Public" 1938 2580 +1938 sem 0 69810 0 +1939 alt 0 1942 1937 2580 +1940 t "RaiseEvent" 1941 2581 +1941 sem 0 69848 0 +1942 alt 0 1945 1940 2581 +1943 t "ReadOnly" 1944 2582 +1944 sem 0 69884 0 +1945 alt 0 1948 1943 2582 +1946 t "ReDim" 1947 2583 +1947 sem 0 69918 0 +1948 alt 0 1951 1946 2583 +1949 t "RemoveHandl 1950 2584 +1950 sem 0 69958 0 +1951 alt 0 1954 1949 2584 +1952 t "Resume" 1953 2585 +1953 sem 0 69993 0 +1954 alt 0 1957 1952 2585 +1955 t "Return" 1956 2586 +1956 sem 0 70028 0 +1957 alt 0 1960 1955 2586 +1958 t "Select" 1959 2587 +1959 sem 0 70063 0 +1960 alt 0 1963 1958 2587 +1961 t "Set" 1962 2588 +1962 sem 0 70096 0 +1963 alt 0 1966 1961 2588 +1964 t "Shadows" 1965 2589 +1965 sem 0 70132 0 +1966 alt 0 1969 1964 2589 +1967 t "Shared" 1968 2590 +1968 sem 0 70167 0 +1969 alt 0 1972 1967 2590 +1970 t "Short" 1971 2591 +1971 sem 0 70201 0 +1972 alt 0 1975 1970 2591 +1973 t "Single" 1974 2592 +1974 sem 0 70236 0 +1975 alt 0 1978 1973 2592 +1976 t "Static" 1977 2593 +1977 sem 0 70271 0 +1978 alt 0 1981 1976 2593 +1979 t "Step" 1980 2594 +1980 sem 0 70304 0 +1981 alt 0 1984 1979 2594 +1982 t "Stop" 1983 2595 +1983 sem 0 70337 0 +1984 alt 0 1987 1982 2595 +1985 t "String" 1986 2596 +1986 sem 0 70372 0 +1987 alt 0 1990 1985 2596 +1988 t "Structure" 1989 2597 +1989 sem 0 70409 0 +1990 alt 0 1993 1988 2597 +1991 t "Sub" 1992 2598 +1992 sem 0 70442 0 +1993 alt 0 1996 1991 2598 +1994 t "SyncLock" 1995 2599 +1995 sem 0 70478 0 +1996 alt 0 1999 1994 2599 +1997 t "Then" 1998 2600 +1998 sem 0 70511 0 +1999 alt 0 2002 1997 2600 +2000 t "Throw" 2001 2601 +2001 sem 0 70545 0 +2002 alt 0 2005 2000 2601 +2003 t "To" 2004 2602 +2004 sem 0 70577 0 +2005 alt 0 2008 2003 2602 +2006 t "True" 2007 2603 +2007 sem 0 70610 0 +2008 alt 0 2011 2006 2603 +2009 t "Try" 2010 2604 +2010 sem 0 70643 0 +2011 alt 0 2014 2009 2604 +2012 t "TypeOf" 2013 2605 +2013 sem 0 70678 0 +2014 alt 0 2017 2012 2605 +2015 t "Unicode" 2016 2606 +2016 sem 0 70714 0 +2017 alt 0 2020 2015 2606 +2018 t "Until" 2019 2607 +2019 sem 0 70748 0 +2020 alt 0 2023 2018 2607 +2021 t "Variant" 2022 2608 +2022 sem 0 70784 0 +2023 alt 0 2026 2021 2608 +2024 t "Wend" 2025 2609 +2025 sem 0 70817 0 +2026 alt 0 2029 2024 2609 +2027 t "When" 2028 2610 +2028 sem 0 70850 0 +2029 alt 0 2032 2027 2610 +2030 t "While" 2031 2611 +2031 sem 0 70884 0 +2032 alt 0 2035 2030 2611 +2033 t "With" 2034 2612 +2034 sem 0 70917 0 +2035 alt 0 2038 2033 2612 +2036 t "WithEvents" 2037 2613 +2037 sem 0 70955 0 +2038 alt 0 2041 2036 2613 +2039 t "WriteOnly" 2040 2614 +2040 sem 0 70992 0 +2041 alt 0 2044 2039 2614 +2042 t "Xor" 2043 2615 +2043 sem 0 71025 0 +2044 alt 0 2047 2042 2615 +2045 t "Continue" 2046 2616 +2046 sem 0 71061 0 +2047 alt 0 2050 2045 2616 +2048 t "Operator" 2049 2617 +2049 sem 0 71097 0 +2050 alt 0 2053 2048 2617 +2051 t "Using" 2052 2618 +2052 sem 0 71131 0 +2053 alt 0 2056 2051 2618 +2054 t "IsNot" 2055 2619 +2055 sem 0 71165 0 +2056 alt 0 2059 2054 2619 +2057 t "SByte" 2058 2620 +2058 sem 0 71199 0 +2059 alt 0 2062 2057 2620 +2060 t "UInteger" 2061 2621 +2061 sem 0 71235 0 +2062 alt 0 2065 2060 2621 +2063 t "ULong" 2064 2622 +2064 sem 0 71269 0 +2065 alt 0 2068 2063 2622 +2066 t "UShort" 2067 2623 +2067 sem 0 71304 0 +2068 alt 0 2071 2066 2623 +2069 t "Of" 2070 2624 +2070 sem 0 71336 0 +2071 alt 0 2074 2069 2624 +2072 t "Narrowing" 2073 2625 +2073 sem 0 71373 0 +2074 alt 0 2077 2072 2625 +2075 t "Widening" 2076 2626 +2076 sem 0 71409 0 +2077 alt 0 2080 2075 2626 +2078 t "Partial" 2079 2627 +2079 sem 0 71445 0 +2080 alt 0 0 2078 2627 +2081 t "Boolean" 2082 2634 +2082 sem 0 71564 0 +2083 t "Date" 2084 2635 +2084 sem 0 71600 0 +2085 alt 0 2086 2081 2634 +2086 alt 0 2089 2083 2635 +2087 t "Char" 2088 2636 +2088 sem 0 71633 0 +2089 alt 0 2092 2087 2636 +2090 t "String" 2091 2637 +2091 sem 0 71668 0 +2092 alt 0 2095 2090 2637 +2093 t "Decimal" 2094 2638 +2094 sem 0 71706 0 +2095 alt 0 2098 2093 2638 +2096 t "Byte" 2097 2639 +2097 sem 0 71742 0 +2098 alt 0 2101 2096 2639 +2099 t "Short" 2100 2640 +2100 sem 0 71776 0 +2101 alt 0 2104 2099 2640 +2102 t "Integer" 2103 2641 +2103 sem 0 71813 0 +2104 alt 0 2107 2102 2641 +2105 t "Long" 2106 2642 +2106 sem 0 71849 0 +2107 alt 0 2110 2105 2642 +2108 t "Single" 2109 2643 +2109 sem 0 71884 0 +2110 alt 0 2113 2108 2643 +2111 t "Double" 2112 2644 +2112 sem 0 71921 0 +2113 alt 0 2116 2111 2644 +2114 t "UInteger" 2115 2645 +2115 sem 0 71959 0 +2116 alt 0 2119 2114 2645 +2117 t "ULong" 2118 2646 +2118 sem 0 71997 0 +2119 alt 0 2122 2117 2646 +2120 t "UShort" 2121 2647 +2121 sem 0 72033 0 +2122 alt 0 2125 2120 2647 +2123 t "SByte" 2124 2648 +2124 sem 0 72069 0 +2125 alt 0 0 2123 2648 +2126 t "ByVal" 2127 2653 +2127 sem 0 72151 0 +2128 t "ByRef" 2129 2654 +2129 sem 0 72196 0 +2130 alt 0 2131 2126 2653 +2131 alt 0 2134 2128 2654 +2132 t "Optional" 2133 2655 +2133 sem 0 72244 0 +2134 alt 0 2137 2132 2655 +2135 t "ParamArray" 2136 2656 +2136 sem 0 72299 0 +2137 alt 0 0 2135 2656 +2138 t "Public" 2139 2660 +2139 sem 0 72382 0 +2140 t "Protected" 2141 2661 +2141 sem 0 72429 0 +2142 alt 0 2143 2138 2660 +2143 alt 0 2146 2140 2661 +2144 t "Friend" 2145 2662 +2145 sem 0 72477 0 +2146 alt 0 2149 2144 2662 +2147 t "Private" 2148 2663 +2148 sem 0 72525 0 +2149 alt 0 2152 2147 2663 +2150 t "Shared" 2151 2664 +2151 sem 0 72571 0 +2152 alt 0 2155 2150 2664 +2153 t "Shadows" 2154 2665 +2154 sem 0 72617 0 +2155 alt 0 2158 2153 2665 +2156 t "MustInherit 2157 2666 +2157 sem 0 72663 0 +2158 alt 0 2161 2156 2666 +2159 t "NotInherita 2160 2667 +2160 sem 0 72716 0 +2161 alt 0 0 2159 2667 +2162 t "MustInherit 2163 2671 +2163 sem 0 72799 0 +2164 t "Default" 2165 2672 +2165 sem 0 72844 0 +2166 alt 0 2167 2162 2671 +2167 alt 0 2170 2164 2672 +2168 t "Friend" 2169 2673 +2169 sem 0 72887 0 +2170 alt 0 2173 2168 2673 +2171 t "Shadows" 2172 2674 +2172 sem 0 72932 0 +2173 alt 0 2176 2171 2674 +2174 t "Overrides" 2175 2675 +2175 sem 0 72973 0 +2176 alt 0 2179 2174 2675 +2177 t "MustOverrid 2178 2676 +2178 sem 0 73022 0 +2179 alt 0 2182 2177 2676 +2180 t "Private" 2181 2677 +2181 sem 0 73067 0 +2182 alt 0 2185 2180 2677 +2183 t "Protected" 2184 2678 +2184 sem 0 73112 0 +2185 alt 0 2188 2183 2678 +2186 t "Public" 2187 2679 +2187 sem 0 73157 0 +2188 alt 0 2191 2186 2679 +2189 t "NotInherita 2190 2680 +2190 sem 0 73205 0 +2191 alt 0 2194 2189 2680 +2192 t "NotOverrida 2193 2681 +2193 sem 0 73253 0 +2194 alt 0 2197 2192 2681 +2195 t "Shared" 2196 2682 +2196 sem 0 73295 0 +2197 alt 0 2200 2195 2682 +2198 t "Overridable 2199 2683 +2199 sem 0 73341 0 +2200 alt 0 2203 2198 2683 +2201 t "Overloads" 2202 2684 +2202 sem 0 73386 0 +2203 alt 0 2206 2201 2684 +2204 t "ReadOnly" 2205 2685 +2205 sem 0 73466 0 +2206 alt 0 2209 2204 2685 +2207 t "WriteOnly" 2208 2686 +2208 sem 0 73522 0 +2209 alt 0 2212 2207 2686 +2210 t "WithEvents" 2211 2687 +2211 sem 0 73545 0 +2212 alt 0 2215 2210 2687 +2213 t "Dim" 2214 2688 +2214 sem 0 73590 0 +2215 alt 0 0 2213 2688 First: node = 2 @@ -8095,308 +8095,308 @@ EOL ":" Cross reference list: -------------------- - "-" 1367 1580 2261 - "&" 1581 - "&=" 1384 - "(" 641 644 739 751 763 779 853 898 924 993 1006 1029 1079 - 1168 1235 1417 1428 1429 1431 1436 1451 1612 1704 1764 1998 2210 - ")" 641 644 739 751 763 779 853 898 924 993 1006 1029 1079 - 1168 1235 1417 1428 1429 1431 1444 1459 1612 1709 1791 1998 2210 - "*" 1369 1595 - "*=" 1387 - "," 479 1047 1062 1246 1272 1293 1305 1322 1336 1428 1440 1455 1634 - 1721 1732 1733 1778 1818 1819 1844 1955 2004 2010 2079 2095 2104 - 2352 - "." 1335 1336 1342 1344 1420 1426 1435 1448 1450 2456 - "/" 1596 - "/=" 1388 - ":" 466 1647 1731 1732 1770 1782 1815 1917 2145 2152 2165 - "\\" 1597 - "\\=" 1389 - "^" 1599 - "^=" 1390 - "{" 1265 - "}" 1276 - "+" 1366 1579 - "+=" 1385 - "<" 1542 1726 1801 2368 - "<<" 1564 - "<<=" 1391 - "<=" 1544 2370 - "<>" 1526 2373 - "=" 496 813 1188 1225 1383 1527 1647 1770 1782 1877 2074 2215 2372 - "-=" 1386 - ">" 1543 1734 1820 2369 - ">=" 1545 2371 - ">>" 1565 - ">>=" 1392 - "AddHandler" 2003 2476 - "AddressOf" 1430 2477 - "Alias" 992 1005 2478 - "And" 1506 2479 - "AndAlso" 1491 2480 - "Ansi" 1281 2481 - "As" 607 645 740 764 780 925 1007 1027 1080 1187 1206 1215 1863 - 2208 2234 2440 2482 - "Assembly" 1726 1732 2483 - "Auto" 1282 2484 - "Binary" 443 2465 - "Boolean" 2485 2633 - "ByRef" 2486 2653 - "Byte" 2487 2638 - "ByVal" 2488 2652 - "Call" 2204 2489 - "Case" 2159 2165 2490 - "Catch" 2439 2491 - "CBool" 1470 2492 - "CByte" 1471 2493 - "CChar" 1472 2494 - "CDate" 1473 2495 - "CDbl" 1475 2496 - "CDec" 1474 2497 - "Char" 2498 2635 - "CInt" 1476 2499 - "Class" 547 670 2500 - "CLng" 1477 2501 - "CObj" 1478 2502 - "Compare" 443 2466 - "Const" 1056 1938 2503 - "Continue" 1988 2615 - "CShort" 1479 2504 - "CSng" 1480 2505 - "CStr" 1481 2506 - "CType" 1428 2507 - "Date" 2508 2634 - "Decimal" 2509 2637 - "Declare" 978 2510 - "Default" 2511 2671 - "Delegate" 631 2512 - "Dim" 1940 2513 2687 - "DirectCast" 1428 2514 - "Do" 1976 1988 2021 2515 - "Double" 2516 2643 - "Each" 2052 2517 - "Else" 2120 2131 2147 2363 2518 - "ElseIf" 2121 2519 - "End" 656 670 684 699 708 714 895 903 969 1113 1158 1175 1893 - 1995 2016 2111 2136 2176 2221 2410 2423 2520 - "EndIf" 2521 - "Enum" 596 708 2522 - "Erase" 2097 2523 - "Error" 1347 2086 2259 2524 - "Event" 736 1018 1803 2525 - "Exit" 1968 2526 - "Explicit" 437 2527 - "False" 1415 2528 - "Finally" 2422 2529 - "For" 1978 1988 2043 2530 - "Friend" 2531 2661 2672 - "Function" 643 760 915 969 1002 1972 2532 - "Get" 1152 1158 2533 - "GetType" 1431 2534 - "GoSub" 2535 - "GoTo" 2261 2296 2536 - "Handles" 1292 2537 - "If" 2109 2120 2136 2538 - "Implements" 1317 1335 2539 - "Imports" 472 2540 - "In" 2053 2541 - "Inherits" 826 1302 2542 - "Integer" 2543 2640 - "Interface" 615 714 2544 - "Is" 1432 1550 2366 2545 - "IsNot" 1551 2618 - "Let" 2546 - "Lib" 991 1004 2547 - "Like" 1528 2548 - "Long" 2549 2641 - "Loop" 2028 2038 2550 - "Me" 1421 2551 - "Mod" 1598 2552 - "Module" 563 699 1726 1732 2553 - "MustInherit 2554 2665 2670 - "MustOverrid 2555 2675 - "MyBase" 1344 1423 2556 - "MyClass" 1424 2557 - "Namespace" 516 656 2558 - "Narrowing" 2624 - "New" 898 1611 2210 2559 - "Next" 2055 2076 2283 2341 2560 - "Not" 1511 2561 - "Nothing" 1416 2562 - "NotInherita 2563 2666 2679 - "NotOverrida 2564 2680 - "Object" 1684 2565 - "Of" 2623 - "Off" 459 - "On" 457 2259 2566 - "Operator" 2616 - "Option" 435 2567 - "Optional" 2568 2654 - "Or" 1501 2569 - "OrElse" 1486 2570 - "Overloads" 2571 2683 - "Overridable 2572 2682 - "Overrides" 2573 2674 - "ParamArray" 2574 2655 - "Partial" 546 2626 - "Preserve" 2088 2575 - "Private" 2576 2662 2676 - "Property" 776 1073 1113 1974 2577 - "Protected" 2578 2660 2677 - "Public" 2579 2659 2678 - "RaiseEvent" 1997 2580 - "ReadOnly" 2581 2684 - "ReDim" 2088 2582 - "RemoveHandl 2009 2583 - "Resume" 2283 2341 2342 2584 - "Return" 1804 1992 2585 - "SByte" 2619 2647 - "Select" 1984 2159 2176 2586 - "Set" 1167 1175 2587 - "Shadows" 2588 2664 2673 - "Shared" 2589 2663 2681 - "Short" 2590 2639 - "Single" 2591 2642 - "Static" 1939 2592 - "Step" 2074 2593 - "Stop" 2107 2594 - "Strict" 440 - "String" 2595 2636 - "Structure" 579 684 2596 - "Sub" 640 748 839 895 903 989 1970 2597 - "SyncLock" 1994 1995 2598 - "Text" 444 2464 - "Then" 2109 2124 2599 - "Throw" 1990 2600 - "To" 2074 2379 2601 - "True" 1414 2602 - "Try" 1980 2419 2423 2603 - "TypeOf" 1432 2604 - "UInteger" 2620 2644 - "ULong" 2621 2645 - "Unicode" 1283 2605 - "Until" 2389 2606 - "UShort" 2622 2646 - "Using" 2205 2221 2617 - "Variant" 2607 - "Wend" 2608 - "When" 2441 2609 - "While" 1982 1988 2015 2016 2388 2610 - "Widening" 2625 - "With" 2398 2410 2611 - "WithEvents" 2612 2686 - "WriteOnly" 2613 2685 - "Xor" 1496 2614 - AccessorDecl-1125 1112 - AdditiveExpr-1571 1561 1567 - AndExpr -1504 1501 1501 - Argument -1641 1438 1441 1453 1456 1632 1635 - ArgumentList-1626 1612 1998 2210 - ArrayInitial-1231 1204 - ArrayInitial-1260 1256 1613 - ArrayNameMod-1689 1203 - ArrayTypeMod-1698 1669 1693 1862 2233 - AssignmentOp-1381 2193 - Attribute -1745 1731 1732 1817 1818 - AttributeArg-1758 1751 - AttributeSec-1795 534 666 680 695 730 764 805 925 1131 1136 1143 1835 - 1845 - Block -1885 890 902 964 1154 1170 1994 2016 2027 2037 2054 2075 2114 - 2125 2132 2169 2220 2405 2420 2422 2443 - CaseClause -2356 2351 2352 - CaseClauses -2346 2165 - CastTarget -1466 1429 - CatchClauses-2430 2421 - Charset -1279 987 - ClassBaseTyp -821 557 - ClassBody -660 559 - ClassMemberD -817 668 697 - ConditionalA-1489 1486 1486 - ConditionalO-1484 1353 - ConstantDecl-1180 1061 1062 - EmbeddedStat-1961 1918 2141 2145 2147 2152 - EndOfStmt -463 447 481 556 624 828 1325 1735 1893 1894 1994 2015 2026 - 2036 2053 2075 2114 2124 2131 2159 2165 2399 2419 2422 2442 - EnumBody -703 609 - EnumMemberDe -799 706 - EOF 431 - EOL 426 464 466 527 573 589 608 648 657 671 685 700 709 - 715 741 752 774 786 814 862 895 901 903 938 974 994 - 1008 1038 1048 1067 1087 1114 1153 1159 1169 1176 1308 - EqualityExpr-1518 1512 - EventMemberS-1339 1292 1293 - ExclusiveOrE-1499 1496 1496 - Expr -1351 813 1188 1244 1246 1255 1417 1428 1429 1430 1552 1647 1652 - 1771 1784 1877 1990 1992 1994 2004 2004 2010 2010 2015 2026 2038 - 2053 2055 2074 2074 2074 2078 2079 2086 2089 2095 2098 2104 2109 - 2124 2159 2193 2215 2375 2379 2379 2399 2441 - FormalParame-1853 1837 1847 - FormalParame-1829 641 644 739 751 763 779 853 898 924 993 1006 1029 - 1079 1168 - GetAccessorD-1150 1133 1144 - GlobalAttrib-1724 429 - GotoStatemen-2291 2180 2269 - HandlesClaus-1287 858 935 - ident 2463 - Identifier -2462 496 555 572 588 606 623 640 643 738 750 762 778 - 806 848 923 990 1003 1025 1078 1186 1202 1335 1336 1341 1343 - 1346 1418 1420 1647 1805 1861 1997 2205 2307 2440 2455 2475 - IdentifierOr-2470 1426 1435 1448 1450 1769 1781 2456 - ImplementsCl-1329 856 933 1031 1086 - ImportClause -490 477 479 - ImportsStmt -469 428 - InclusiveOrE-1494 1491 1491 - Initializati-1239 1235 - InterfaceBas-1297 624 - InterfaceBod -712 625 - InterfaceMem -722 713 - LabelName -2303 1913 2296 2342 - LiteralChara 1407 - LiteralDate 1411 - LiteralDecim 1412 - LiteralDoubl 1409 - LiteralInteg 1410 2261 2308 - LiteralSingl 1408 - LiteralStrin 991 992 1004 1005 1406 - LocalDeclara-1930 1919 - LoopControlV-2227 2052 2073 - MemberModifi-2669 667 681 696 734 - ModuleBody -689 574 - Multiplicati-1587 1576 1583 - NamespaceBod -654 528 - NamespaceMem -510 430 655 - NonArrayType-1678 1658 1668 - NonModuleDec -539 535 795 837 - NotExpr -1509 1506 1506 - ObjectCreate-1605 1206 1427 - OnErrorState-2253 2178 - OptionStmt -434 427 - OptionValue -455 437 440 - ParameterMod-2651 1860 - PrimitiveTyp-2631 607 1419 1685 - Qualident -2449 497 520 1335 1336 1683 1747 2210 2215 2232 - RankList -1719 1705 - RelationalEx-1534 1523 1530 - ResumeStatem-2335 2182 - SetAccessorD-1163 1137 1140 - ShiftExpr -1556 1539 1547 - SimpleExpr -1396 1371 1432 - Statement -1905 1894 1917 - StructureBod -674 590 - StructureMem -832 682 818 - TryStatement-2415 1987 - TypeImplemen-1312 558 589 - TypeModifier-2658 535 - TypeName -1665 645 740 764 780 827 925 1007 1027 1080 1187 1215 1303 - 1306 1317 1322 1428 1431 1432 1863 2234 2440 - TypeNameWith-1656 1611 - UnaryExpr -1360 1592 1601 2191 2204 - VariableDecl-1197 1046 1047 1954 1955 - VariableInit-1251 1225 1267 1272 - VBNET -421 - WhileOrUntil-2386 2026 2038 - WithStatemen-2393 2001 + "-" 1368 1581 2262 + "&" 1582 + "&=" 1385 + "(" 642 645 740 752 764 780 854 899 925 994 1007 1030 1080 + 1169 1236 1418 1429 1430 1432 1437 1452 1613 1705 1765 1999 2211 + ")" 642 645 740 752 764 780 854 899 925 994 1007 1030 1080 + 1169 1236 1418 1429 1430 1432 1445 1460 1613 1710 1792 1999 2211 + "*" 1370 1596 + "*=" 1388 + "," 480 1048 1063 1247 1273 1294 1306 1323 1337 1429 1441 1456 1635 + 1722 1733 1734 1779 1819 1820 1845 1956 2005 2011 2080 2096 2105 + 2353 + "." 1336 1337 1343 1345 1421 1427 1436 1449 1451 2457 + "/" 1597 + "/=" 1389 + ":" 467 1648 1732 1733 1771 1783 1816 1918 2146 2153 2166 + "\\" 1598 + "\\=" 1390 + "^" 1600 + "^=" 1391 + "{" 1266 + "}" 1277 + "+" 1367 1580 + "+=" 1386 + "<" 1543 1727 1802 2369 + "<<" 1565 + "<<=" 1392 + "<=" 1545 2371 + "<>" 1527 2374 + "=" 497 814 1189 1226 1384 1528 1648 1771 1783 1878 2075 2216 2373 + "-=" 1387 + ">" 1544 1735 1821 2370 + ">=" 1546 2372 + ">>" 1566 + ">>=" 1393 + "AddHandler" 2004 2477 + "AddressOf" 1431 2478 + "Alias" 993 1006 2479 + "And" 1507 2480 + "AndAlso" 1492 2481 + "Ansi" 1282 2482 + "As" 608 646 741 765 781 926 1008 1028 1081 1188 1207 1216 1864 + 2209 2235 2441 2483 + "Assembly" 1727 1733 2484 + "Auto" 1283 2485 + "Binary" 444 2466 + "Boolean" 2486 2634 + "ByRef" 2487 2654 + "Byte" 2488 2639 + "ByVal" 2489 2653 + "Call" 2205 2490 + "Case" 2160 2166 2491 + "Catch" 2440 2492 + "CBool" 1471 2493 + "CByte" 1472 2494 + "CChar" 1473 2495 + "CDate" 1474 2496 + "CDbl" 1476 2497 + "CDec" 1475 2498 + "Char" 2499 2636 + "CInt" 1477 2500 + "Class" 548 671 2501 + "CLng" 1478 2502 + "CObj" 1479 2503 + "Compare" 444 2467 + "Const" 1057 1939 2504 + "Continue" 1989 2616 + "CShort" 1480 2505 + "CSng" 1481 2506 + "CStr" 1482 2507 + "CType" 1429 2508 + "Date" 2509 2635 + "Decimal" 2510 2638 + "Declare" 979 2511 + "Default" 2512 2672 + "Delegate" 632 2513 + "Dim" 1941 2514 2688 + "DirectCast" 1429 2515 + "Do" 1977 1989 2022 2516 + "Double" 2517 2644 + "Each" 2053 2518 + "Else" 2121 2132 2148 2364 2519 + "ElseIf" 2122 2520 + "End" 657 671 685 700 709 715 896 904 970 1114 1159 1176 1894 + 1996 2017 2112 2137 2177 2222 2411 2424 2521 + "EndIf" 2522 + "Enum" 597 709 2523 + "Erase" 2098 2524 + "Error" 1348 2087 2260 2525 + "Event" 737 1019 1804 2526 + "Exit" 1969 2527 + "Explicit" 438 2528 + "False" 1416 2529 + "Finally" 2423 2530 + "For" 1979 1989 2044 2531 + "Friend" 2532 2662 2673 + "Function" 644 761 916 970 1003 1973 2533 + "Get" 1153 1159 2534 + "GetType" 1432 2535 + "GoSub" 2536 + "GoTo" 2262 2297 2537 + "Handles" 1293 2538 + "If" 2110 2121 2137 2539 + "Implements" 1318 1336 2540 + "Imports" 473 2541 + "In" 2054 2542 + "Inherits" 827 1303 2543 + "Integer" 2544 2641 + "Interface" 616 715 2545 + "Is" 1433 1551 2367 2546 + "IsNot" 1552 2619 + "Let" 2547 + "Lib" 992 1005 2548 + "Like" 1529 2549 + "Long" 2550 2642 + "Loop" 2029 2039 2551 + "Me" 1422 2552 + "Mod" 1599 2553 + "Module" 564 700 1727 1733 2554 + "MustInherit 2555 2666 2671 + "MustOverrid 2556 2676 + "MyBase" 1345 1424 2557 + "MyClass" 1425 2558 + "Namespace" 517 657 2559 + "Narrowing" 2625 + "New" 899 1612 2211 2560 + "Next" 2056 2077 2284 2342 2561 + "Not" 1512 2562 + "Nothing" 1417 2563 + "NotInherita 2564 2667 2680 + "NotOverrida 2565 2681 + "Object" 1685 2566 + "Of" 2624 + "Off" 460 + "On" 458 2260 2567 + "Operator" 2617 + "Option" 436 2568 + "Optional" 2569 2655 + "Or" 1502 2570 + "OrElse" 1487 2571 + "Overloads" 2572 2684 + "Overridable 2573 2683 + "Overrides" 2574 2675 + "ParamArray" 2575 2656 + "Partial" 547 2627 + "Preserve" 2089 2576 + "Private" 2577 2663 2677 + "Property" 777 1074 1114 1975 2578 + "Protected" 2579 2661 2678 + "Public" 2580 2660 2679 + "RaiseEvent" 1998 2581 + "ReadOnly" 2582 2685 + "ReDim" 2089 2583 + "RemoveHandl 2010 2584 + "Resume" 2284 2342 2343 2585 + "Return" 1805 1993 2586 + "SByte" 2620 2648 + "Select" 1985 2160 2177 2587 + "Set" 1168 1176 2588 + "Shadows" 2589 2665 2674 + "Shared" 2590 2664 2682 + "Short" 2591 2640 + "Single" 2592 2643 + "Static" 1940 2593 + "Step" 2075 2594 + "Stop" 2108 2595 + "Strict" 441 + "String" 2596 2637 + "Structure" 580 685 2597 + "Sub" 641 749 840 896 904 990 1971 2598 + "SyncLock" 1995 1996 2599 + "Text" 445 2465 + "Then" 2110 2125 2600 + "Throw" 1991 2601 + "To" 2075 2380 2602 + "True" 1415 2603 + "Try" 1981 2420 2424 2604 + "TypeOf" 1433 2605 + "UInteger" 2621 2645 + "ULong" 2622 2646 + "Unicode" 1284 2606 + "Until" 2390 2607 + "UShort" 2623 2647 + "Using" 2206 2222 2618 + "Variant" 2608 + "Wend" 2609 + "When" 2442 2610 + "While" 1983 1989 2016 2017 2389 2611 + "Widening" 2626 + "With" 2399 2411 2612 + "WithEvents" 2613 2687 + "WriteOnly" 2614 2686 + "Xor" 1497 2615 + AccessorDecl-1126 1113 + AdditiveExpr-1572 1562 1568 + AndExpr -1505 1502 1502 + Argument -1642 1439 1442 1454 1457 1633 1636 + ArgumentList-1627 1613 1999 2211 + ArrayInitial-1232 1205 + ArrayInitial-1261 1257 1614 + ArrayNameMod-1690 1204 + ArrayTypeMod-1699 1670 1694 1863 2234 + AssignmentOp-1382 2194 + Attribute -1746 1732 1733 1818 1819 + AttributeArg-1759 1752 + AttributeSec-1796 535 667 681 696 731 765 806 926 1132 1137 1144 1836 + 1846 + Block -1886 891 903 965 1155 1171 1995 2017 2028 2038 2055 2076 2115 + 2126 2133 2170 2221 2406 2421 2423 2444 + CaseClause -2357 2352 2353 + CaseClauses -2347 2166 + CastTarget -1467 1430 + CatchClauses-2431 2422 + Charset -1280 988 + ClassBaseTyp -822 558 + ClassBody -661 560 + ClassMemberD -818 669 698 + ConditionalA-1490 1487 1487 + ConditionalO-1485 1354 + ConstantDecl-1181 1062 1063 + EmbeddedStat-1962 1919 2142 2146 2148 2153 + EndOfStmt -464 448 482 557 625 829 1326 1736 1894 1895 1995 2016 2027 + 2037 2054 2076 2115 2125 2132 2160 2166 2400 2420 2423 2443 + EnumBody -704 610 + EnumMemberDe -800 707 + EOF 432 + EOL 427 465 467 528 574 590 609 649 658 672 686 701 710 + 716 742 753 775 787 815 863 896 902 904 939 975 995 + 1009 1039 1049 1068 1088 1115 1154 1160 1170 1177 1309 + EqualityExpr-1519 1513 + EventMemberS-1340 1293 1294 + ExclusiveOrE-1500 1497 1497 + Expr -1352 814 1189 1245 1247 1256 1418 1429 1430 1431 1553 1648 1653 + 1772 1785 1878 1991 1993 1995 2005 2005 2011 2011 2016 2027 2039 + 2054 2056 2075 2075 2075 2079 2080 2087 2090 2096 2099 2105 2110 + 2125 2160 2194 2216 2376 2380 2380 2400 2442 + FormalParame-1854 1838 1848 + FormalParame-1830 642 645 740 752 764 780 854 899 925 994 1007 1030 + 1080 1169 + GetAccessorD-1151 1134 1145 + GlobalAttrib-1725 430 + GotoStatemen-2292 2181 2270 + HandlesClaus-1288 859 936 + ident 2464 + Identifier -2463 497 556 573 589 607 624 641 644 739 751 763 779 + 807 849 924 991 1004 1026 1079 1187 1203 1336 1337 1342 1344 + 1347 1419 1421 1648 1806 1862 1998 2206 2308 2441 2456 2476 + IdentifierOr-2471 1427 1436 1449 1451 1770 1782 2457 + ImplementsCl-1330 857 934 1032 1087 + ImportClause -491 478 480 + ImportsStmt -470 429 + InclusiveOrE-1495 1492 1492 + Initializati-1240 1236 + InterfaceBas-1298 625 + InterfaceBod -713 626 + InterfaceMem -723 714 + LabelName -2304 1914 2297 2343 + LiteralChara 1408 + LiteralDate 1412 + LiteralDecim 1413 + LiteralDoubl 1410 + LiteralInteg 1411 2262 2309 + LiteralSingl 1409 + LiteralStrin 992 993 1005 1006 1407 + LocalDeclara-1931 1920 + LoopControlV-2228 2053 2074 + MemberModifi-2670 668 682 697 735 + ModuleBody -690 575 + Multiplicati-1588 1577 1584 + NamespaceBod -655 529 + NamespaceMem -511 431 656 + NonArrayType-1679 1659 1669 + NonModuleDec -540 536 796 838 + NotExpr -1510 1507 1507 + ObjectCreate-1606 1207 1428 + OnErrorState-2254 2179 + OptionStmt -435 428 + OptionValue -456 438 441 + ParameterMod-2652 1861 + PrimitiveTyp-2632 608 1420 1686 + Qualident -2450 498 521 1336 1337 1684 1748 2211 2216 2233 + RankList -1720 1706 + RelationalEx-1535 1524 1531 + ResumeStatem-2336 2183 + SetAccessorD-1164 1138 1141 + ShiftExpr -1557 1540 1548 + SimpleExpr -1397 1372 1433 + Statement -1906 1895 1918 + StructureBod -675 591 + StructureMem -833 683 819 + TryStatement-2416 1988 + TypeImplemen-1313 559 590 + TypeModifier-2659 536 + TypeName -1666 646 741 765 781 828 926 1008 1028 1081 1188 1216 1304 + 1307 1318 1323 1429 1432 1433 1864 2235 2441 + TypeNameWith-1657 1612 + UnaryExpr -1361 1593 1602 2192 2205 + VariableDecl-1198 1047 1048 1955 1956 + VariableInit-1252 1226 1268 1273 + VBNET -422 + WhileOrUntil-2387 2027 2039 + WithStatemen-2394 2002 diff --git a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs index 1fdd461c8d..925d25c3cc 100644 --- a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs +++ b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs @@ -2,6 +2,7 @@ #line 1 "VBNET.ATG" using System.Drawing; using System.Collections; +using System.Collections.Generic; using System.Collections.Specialized; using System.Text; using ICSharpCode.NRefactory.Parser.AST; @@ -24,7 +25,7 @@ internal class Parser : AbstractParser const bool x = false; -#line 10 "VBNET.ATG" +#line 11 "VBNET.ATG" private string assemblyName = null; private Stack withStatements; private StringBuilder qualidentBuilder = new StringBuilder(); @@ -236,7 +237,7 @@ bool IsLocalAttrTarget() { void VBNET() { -#line 423 "VBNET.ATG" +#line 424 "VBNET.ATG" compilationUnit = new CompilationUnit(); withStatements = new Stack(); @@ -250,7 +251,7 @@ bool IsLocalAttrTarget() { ImportsStmt(); } while ( -#line 429 "VBNET.ATG" +#line 430 "VBNET.ATG" IsGlobalAttrTarget()) { GlobalAttributeSection(); } @@ -262,49 +263,49 @@ IsGlobalAttrTarget()) { void OptionStmt() { -#line 434 "VBNET.ATG" +#line 435 "VBNET.ATG" INode node = null; bool val = true; Expect(135); -#line 435 "VBNET.ATG" +#line 436 "VBNET.ATG" Point startPos = t.Location; if (la.kind == 94) { lexer.NextToken(); if (la.kind == 133 || la.kind == 134) { OptionValue( -#line 437 "VBNET.ATG" +#line 438 "VBNET.ATG" ref val); } -#line 438 "VBNET.ATG" +#line 439 "VBNET.ATG" node = new OptionDeclaration(OptionType.Explicit, val); } else if (la.kind == 164) { lexer.NextToken(); if (la.kind == 133 || la.kind == 134) { OptionValue( -#line 440 "VBNET.ATG" +#line 441 "VBNET.ATG" ref val); } -#line 441 "VBNET.ATG" +#line 442 "VBNET.ATG" node = new OptionDeclaration(OptionType.Strict, val); } else if (la.kind == 69) { lexer.NextToken(); if (la.kind == 50) { lexer.NextToken(); -#line 443 "VBNET.ATG" +#line 444 "VBNET.ATG" node = new OptionDeclaration(OptionType.CompareBinary, val); } else if (la.kind == 169) { lexer.NextToken(); -#line 444 "VBNET.ATG" +#line 445 "VBNET.ATG" node = new OptionDeclaration(OptionType.CompareText, val); } else SynErr(199); } else SynErr(200); EndOfStmt(); -#line 449 "VBNET.ATG" +#line 450 "VBNET.ATG" node.StartLocation = startPos; node.EndLocation = t.Location; compilationUnit.AddChild(node); @@ -313,33 +314,33 @@ ref val); void ImportsStmt() { -#line 470 "VBNET.ATG" +#line 471 "VBNET.ATG" ArrayList usings = new ArrayList(); Expect(107); -#line 474 "VBNET.ATG" +#line 475 "VBNET.ATG" Point startPos = t.Location; Using u; ImportClause( -#line 477 "VBNET.ATG" +#line 478 "VBNET.ATG" out u); -#line 477 "VBNET.ATG" +#line 478 "VBNET.ATG" usings.Add(u); while (la.kind == 12) { lexer.NextToken(); ImportClause( -#line 479 "VBNET.ATG" +#line 480 "VBNET.ATG" out u); -#line 479 "VBNET.ATG" +#line 480 "VBNET.ATG" usings.Add(u); } EndOfStmt(); -#line 483 "VBNET.ATG" +#line 484 "VBNET.ATG" UsingDeclaration usingDeclaration = new UsingDeclaration(usings); usingDeclaration.StartLocation = startPos; usingDeclaration.EndLocation = t.Location; @@ -349,7 +350,7 @@ out u); void GlobalAttributeSection() { -#line 1725 "VBNET.ATG" +#line 1726 "VBNET.ATG" Point startPos = t.Location; Expect(26); if (la.kind == 48) { @@ -358,19 +359,19 @@ out u); lexer.NextToken(); } else SynErr(201); -#line 1728 "VBNET.ATG" +#line 1729 "VBNET.ATG" string attributeTarget = t.val.ToLower();ArrayList attributes = new ArrayList(); ICSharpCode.NRefactory.Parser.AST.Attribute attribute; Expect(13); Attribute( -#line 1731 "VBNET.ATG" +#line 1732 "VBNET.ATG" out attribute); -#line 1731 "VBNET.ATG" +#line 1732 "VBNET.ATG" attributes.Add(attribute); while ( -#line 1732 "VBNET.ATG" +#line 1733 "VBNET.ATG" NotFinalComma()) { if (la.kind == 12) { lexer.NextToken(); @@ -382,10 +383,10 @@ NotFinalComma()) { Expect(13); } Attribute( -#line 1732 "VBNET.ATG" +#line 1733 "VBNET.ATG" out attribute); -#line 1732 "VBNET.ATG" +#line 1733 "VBNET.ATG" attributes.Add(attribute); } if (la.kind == 12) { @@ -394,7 +395,7 @@ out attribute); Expect(25); EndOfStmt(); -#line 1737 "VBNET.ATG" +#line 1738 "VBNET.ATG" AttributeSection section = new AttributeSection(attributeTarget, attributes); section.StartLocation = startPos; section.EndLocation = t.EndLocation; @@ -404,7 +405,7 @@ out attribute); void NamespaceMemberDecl() { -#line 512 "VBNET.ATG" +#line 513 "VBNET.ATG" Modifiers m = new Modifiers(); AttributeSection section;ArrayList attributes = new ArrayList(); string qualident; @@ -412,14 +413,14 @@ out attribute); if (la.kind == 125) { lexer.NextToken(); -#line 518 "VBNET.ATG" +#line 519 "VBNET.ATG" Point startPos = t.Location; Qualident( -#line 520 "VBNET.ATG" +#line 521 "VBNET.ATG" out qualident); -#line 522 "VBNET.ATG" +#line 523 "VBNET.ATG" INode node = new NamespaceDeclaration(qualident); node.StartLocation = startPos; compilationUnit.AddChild(node); @@ -428,42 +429,42 @@ out qualident); Expect(1); NamespaceBody(); -#line 530 "VBNET.ATG" +#line 531 "VBNET.ATG" node.EndLocation = t.Location; compilationUnit.BlockEnd(); } else if (StartOf(2)) { while (la.kind == 26) { AttributeSection( -#line 534 "VBNET.ATG" +#line 535 "VBNET.ATG" out section); -#line 534 "VBNET.ATG" +#line 535 "VBNET.ATG" attributes.Add(section); } while (StartOf(3)) { TypeModifier( -#line 535 "VBNET.ATG" +#line 536 "VBNET.ATG" m); } NonModuleDeclaration( -#line 535 "VBNET.ATG" +#line 536 "VBNET.ATG" m, attributes); } else SynErr(203); } void OptionValue( -#line 455 "VBNET.ATG" +#line 456 "VBNET.ATG" ref bool val) { if (la.kind == 134) { lexer.NextToken(); -#line 457 "VBNET.ATG" +#line 458 "VBNET.ATG" val = true; } else if (la.kind == 133) { lexer.NextToken(); -#line 459 "VBNET.ATG" +#line 460 "VBNET.ATG" val = false; } else SynErr(204); } @@ -480,28 +481,28 @@ ref bool val) { } void ImportClause( -#line 490 "VBNET.ATG" +#line 491 "VBNET.ATG" out Using u) { -#line 492 "VBNET.ATG" +#line 493 "VBNET.ATG" string qualident = null; string aliasident = null; u = null; if ( -#line 496 "VBNET.ATG" +#line 497 "VBNET.ATG" IsAssignment()) { Identifier(); -#line 496 "VBNET.ATG" +#line 497 "VBNET.ATG" aliasident = t.val; Expect(11); } Qualident( -#line 497 "VBNET.ATG" +#line 498 "VBNET.ATG" out qualident); -#line 499 "VBNET.ATG" +#line 500 "VBNET.ATG" if (qualident != null && qualident.Length > 0) { if (aliasident != null) { u = new Using(aliasident, qualident); @@ -525,30 +526,30 @@ out qualident); } void Qualident( -#line 2449 "VBNET.ATG" +#line 2450 "VBNET.ATG" out string qualident) { -#line 2451 "VBNET.ATG" +#line 2452 "VBNET.ATG" string name; qualidentBuilder.Length = 0; Identifier(); -#line 2455 "VBNET.ATG" +#line 2456 "VBNET.ATG" qualidentBuilder.Append(t.val); while ( -#line 2456 "VBNET.ATG" +#line 2457 "VBNET.ATG" DotAndIdentOrKw()) { Expect(10); IdentifierOrKeyword( -#line 2456 "VBNET.ATG" +#line 2457 "VBNET.ATG" out name); -#line 2456 "VBNET.ATG" +#line 2457 "VBNET.ATG" qualidentBuilder.Append('.'); qualidentBuilder.Append(name); } -#line 2458 "VBNET.ATG" +#line 2459 "VBNET.ATG" qualident = qualidentBuilder.ToString(); } @@ -562,35 +563,35 @@ out name); } void AttributeSection( -#line 1795 "VBNET.ATG" +#line 1796 "VBNET.ATG" out AttributeSection section) { -#line 1797 "VBNET.ATG" +#line 1798 "VBNET.ATG" string attributeTarget = "";ArrayList attributes = new ArrayList(); ICSharpCode.NRefactory.Parser.AST.Attribute attribute; Expect(26); -#line 1801 "VBNET.ATG" +#line 1802 "VBNET.ATG" Point startPos = t.Location; if ( -#line 1802 "VBNET.ATG" +#line 1803 "VBNET.ATG" IsLocalAttrTarget()) { if (la.kind == 92) { lexer.NextToken(); -#line 1803 "VBNET.ATG" +#line 1804 "VBNET.ATG" attributeTarget = "event"; } else if (la.kind == 154) { lexer.NextToken(); -#line 1804 "VBNET.ATG" +#line 1805 "VBNET.ATG" attributeTarget = "return"; } else { Identifier(); -#line 1807 "VBNET.ATG" +#line 1808 "VBNET.ATG" string val = t.val.ToLower(); if (val != "field" || val != "method" || val != "module" || val != "param" || @@ -603,20 +604,20 @@ IsLocalAttrTarget()) { Expect(13); } Attribute( -#line 1817 "VBNET.ATG" +#line 1818 "VBNET.ATG" out attribute); -#line 1817 "VBNET.ATG" +#line 1818 "VBNET.ATG" attributes.Add(attribute); while ( -#line 1818 "VBNET.ATG" +#line 1819 "VBNET.ATG" NotFinalComma()) { Expect(12); Attribute( -#line 1818 "VBNET.ATG" +#line 1819 "VBNET.ATG" out attribute); -#line 1818 "VBNET.ATG" +#line 1819 "VBNET.ATG" attributes.Add(attribute); } if (la.kind == 12) { @@ -624,7 +625,7 @@ out attribute); } Expect(25); -#line 1822 "VBNET.ATG" +#line 1823 "VBNET.ATG" section = new AttributeSection(attributeTarget, attributes); section.StartLocation = startPos; section.EndLocation = t.EndLocation; @@ -632,62 +633,62 @@ out attribute); } void TypeModifier( -#line 2658 "VBNET.ATG" +#line 2659 "VBNET.ATG" Modifiers m) { switch (la.kind) { case 148: { lexer.NextToken(); -#line 2659 "VBNET.ATG" +#line 2660 "VBNET.ATG" m.Add(Modifier.Public); break; } case 147: { lexer.NextToken(); -#line 2660 "VBNET.ATG" +#line 2661 "VBNET.ATG" m.Add(Modifier.Protected); break; } case 98: { lexer.NextToken(); -#line 2661 "VBNET.ATG" +#line 2662 "VBNET.ATG" m.Add(Modifier.Internal); break; } case 145: { lexer.NextToken(); -#line 2662 "VBNET.ATG" +#line 2663 "VBNET.ATG" m.Add(Modifier.Private); break; } case 158: { lexer.NextToken(); -#line 2663 "VBNET.ATG" +#line 2664 "VBNET.ATG" m.Add(Modifier.Static); break; } case 157: { lexer.NextToken(); -#line 2664 "VBNET.ATG" +#line 2665 "VBNET.ATG" m.Add(Modifier.New); break; } case 121: { lexer.NextToken(); -#line 2665 "VBNET.ATG" +#line 2666 "VBNET.ATG" m.Add(Modifier.Abstract); break; } case 130: { lexer.NextToken(); -#line 2666 "VBNET.ATG" +#line 2667 "VBNET.ATG" m.Add(Modifier.Sealed); break; } @@ -696,27 +697,27 @@ Modifiers m) { } void NonModuleDeclaration( -#line 539 "VBNET.ATG" +#line 540 "VBNET.ATG" Modifiers m,ArrayList attributes) { -#line 541 "VBNET.ATG" +#line 542 "VBNET.ATG" string name = String.Empty; ArrayList names = null; /*bool isPartialClass = false;*/ switch (la.kind) { case 66: case 197: { -#line 544 "VBNET.ATG" +#line 545 "VBNET.ATG" m.Check(Modifier.Classes); if (la.kind == 197) { lexer.NextToken(); -#line 546 "VBNET.ATG" +#line 547 "VBNET.ATG" } Expect(66); -#line 548 "VBNET.ATG" +#line 549 "VBNET.ATG" TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes); /*newType.IsPartialType = isPartialClass;*/ compilationUnit.AddChild(newType); @@ -726,30 +727,30 @@ Modifiers m,ArrayList attributes) { Identifier(); -#line 555 "VBNET.ATG" +#line 556 "VBNET.ATG" newType.Name = t.val; newType.StartLocation = t.EndLocation; EndOfStmt(); if (la.kind == 109) { ClassBaseType( -#line 557 "VBNET.ATG" +#line 558 "VBNET.ATG" out name); -#line 557 "VBNET.ATG" +#line 558 "VBNET.ATG" newType.BaseTypes.Add(name); } while (la.kind == 106) { TypeImplementsClause( -#line 558 "VBNET.ATG" +#line 559 "VBNET.ATG" out names); -#line 558 "VBNET.ATG" +#line 559 "VBNET.ATG" newType.BaseTypes.AddRange(names); } ClassBody( -#line 559 "VBNET.ATG" +#line 560 "VBNET.ATG" newType); -#line 561 "VBNET.ATG" +#line 562 "VBNET.ATG" compilationUnit.BlockEnd(); break; @@ -757,7 +758,7 @@ newType); case 120: { lexer.NextToken(); -#line 565 "VBNET.ATG" +#line 566 "VBNET.ATG" m.Check(Modifier.VBModules); TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes); compilationUnit.AddChild(newType); @@ -767,14 +768,14 @@ newType); Identifier(); -#line 572 "VBNET.ATG" +#line 573 "VBNET.ATG" newType.Name = t.val; newType.StartLocation = t.EndLocation; Expect(1); ModuleBody( -#line 574 "VBNET.ATG" +#line 575 "VBNET.ATG" newType); -#line 576 "VBNET.ATG" +#line 577 "VBNET.ATG" newType.EndLocation = t.Location; compilationUnit.BlockEnd(); @@ -783,7 +784,7 @@ newType); case 166: { lexer.NextToken(); -#line 581 "VBNET.ATG" +#line 582 "VBNET.ATG" m.Check(Modifier.VBStructures); TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes); compilationUnit.AddChild(newType); @@ -793,22 +794,22 @@ newType); Identifier(); -#line 588 "VBNET.ATG" +#line 589 "VBNET.ATG" newType.Name = t.val; newType.StartLocation = t.EndLocation; Expect(1); while (la.kind == 106) { TypeImplementsClause( -#line 589 "VBNET.ATG" +#line 590 "VBNET.ATG" out baseInterfaces); -#line 589 "VBNET.ATG" +#line 590 "VBNET.ATG" newType.BaseTypes.AddRange(baseInterfaces); } StructureBody( -#line 590 "VBNET.ATG" +#line 591 "VBNET.ATG" newType); -#line 592 "VBNET.ATG" +#line 593 "VBNET.ATG" newType.EndLocation = t.Location; compilationUnit.BlockEnd(); @@ -817,7 +818,7 @@ newType); case 89: { lexer.NextToken(); -#line 598 "VBNET.ATG" +#line 599 "VBNET.ATG" m.Check(Modifier.VBEnums); TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes); @@ -828,23 +829,23 @@ newType); Identifier(); -#line 606 "VBNET.ATG" +#line 607 "VBNET.ATG" newType.Name = t.val; newType.StartLocation = t.EndLocation; if (la.kind == 47) { lexer.NextToken(); PrimitiveTypeName( -#line 607 "VBNET.ATG" +#line 608 "VBNET.ATG" out name); -#line 607 "VBNET.ATG" +#line 608 "VBNET.ATG" newType.BaseTypes.Add(name); } Expect(1); EnumBody( -#line 609 "VBNET.ATG" +#line 610 "VBNET.ATG" newType); -#line 611 "VBNET.ATG" +#line 612 "VBNET.ATG" newType.EndLocation = t.Location; compilationUnit.BlockEnd(); @@ -853,7 +854,7 @@ newType); case 111: { lexer.NextToken(); -#line 617 "VBNET.ATG" +#line 618 "VBNET.ATG" m.Check(Modifier.VBInterfacs); TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes); compilationUnit.AddChild(newType); @@ -862,22 +863,22 @@ newType); Identifier(); -#line 623 "VBNET.ATG" +#line 624 "VBNET.ATG" newType.Name = t.val; newType.StartLocation = t.EndLocation; EndOfStmt(); while (la.kind == 109) { InterfaceBase( -#line 624 "VBNET.ATG" +#line 625 "VBNET.ATG" out baseInterfaces); -#line 624 "VBNET.ATG" +#line 625 "VBNET.ATG" newType.BaseTypes.AddRange(baseInterfaces.ToArray()); } InterfaceBody( -#line 625 "VBNET.ATG" +#line 626 "VBNET.ATG" newType); -#line 627 "VBNET.ATG" +#line 628 "VBNET.ATG" newType.EndLocation = t.Location; compilationUnit.BlockEnd(); @@ -886,7 +887,7 @@ newType); case 79: { lexer.NextToken(); -#line 633 "VBNET.ATG" +#line 634 "VBNET.ATG" m.Check(Modifier.VBDelegates); DelegateDeclaration delegateDeclr = new DelegateDeclaration(m.Modifier, attributes);ArrayList p = null; delegateDeclr.ReturnType = new TypeReference("", "System.Void"); @@ -897,57 +898,57 @@ newType); lexer.NextToken(); Identifier(); -#line 640 "VBNET.ATG" +#line 641 "VBNET.ATG" delegateDeclr.Name = t.val; if (la.kind == 23) { lexer.NextToken(); if (StartOf(4)) { FormalParameterList( -#line 641 "VBNET.ATG" +#line 642 "VBNET.ATG" out p); } Expect(24); -#line 641 "VBNET.ATG" +#line 642 "VBNET.ATG" delegateDeclr.Parameters = p; } } else if (la.kind == 99) { lexer.NextToken(); Identifier(); -#line 643 "VBNET.ATG" +#line 644 "VBNET.ATG" delegateDeclr.Name = t.val; if (la.kind == 23) { lexer.NextToken(); if (StartOf(4)) { FormalParameterList( -#line 644 "VBNET.ATG" +#line 645 "VBNET.ATG" out p); } Expect(24); -#line 644 "VBNET.ATG" +#line 645 "VBNET.ATG" delegateDeclr.Parameters = p; } if (la.kind == 47) { lexer.NextToken(); -#line 645 "VBNET.ATG" +#line 646 "VBNET.ATG" TypeReference type; TypeName( -#line 645 "VBNET.ATG" +#line 646 "VBNET.ATG" out type); -#line 645 "VBNET.ATG" +#line 646 "VBNET.ATG" delegateDeclr.ReturnType = type; } } else SynErr(208); -#line 647 "VBNET.ATG" +#line 648 "VBNET.ATG" delegateDeclr.EndLocation = t.EndLocation; Expect(1); -#line 650 "VBNET.ATG" +#line 651 "VBNET.ATG" compilationUnit.AddChild(delegateDeclr); break; @@ -957,271 +958,271 @@ out type); } void ClassBaseType( -#line 821 "VBNET.ATG" +#line 822 "VBNET.ATG" out string name) { -#line 823 "VBNET.ATG" +#line 824 "VBNET.ATG" TypeReference type; name = String.Empty; Expect(109); TypeName( -#line 827 "VBNET.ATG" +#line 828 "VBNET.ATG" out type); -#line 827 "VBNET.ATG" +#line 828 "VBNET.ATG" name = type.Type; EndOfStmt(); } void TypeImplementsClause( -#line 1312 "VBNET.ATG" +#line 1313 "VBNET.ATG" out ArrayList baseInterfaces) { -#line 1314 "VBNET.ATG" +#line 1315 "VBNET.ATG" baseInterfaces = new ArrayList(); TypeReference type = null; Expect(106); TypeName( -#line 1317 "VBNET.ATG" +#line 1318 "VBNET.ATG" out type); -#line 1319 "VBNET.ATG" +#line 1320 "VBNET.ATG" baseInterfaces.Add(type.Type); while (la.kind == 12) { lexer.NextToken(); TypeName( -#line 1322 "VBNET.ATG" +#line 1323 "VBNET.ATG" out type); -#line 1323 "VBNET.ATG" +#line 1324 "VBNET.ATG" baseInterfaces.Add(type.Type); } EndOfStmt(); } void ClassBody( -#line 660 "VBNET.ATG" +#line 661 "VBNET.ATG" TypeDeclaration newType) { -#line 661 "VBNET.ATG" +#line 662 "VBNET.ATG" AttributeSection section; while (StartOf(5)) { -#line 663 "VBNET.ATG" +#line 664 "VBNET.ATG" ArrayList attributes = new ArrayList(); Modifiers m = new Modifiers(); while (la.kind == 26) { AttributeSection( -#line 666 "VBNET.ATG" +#line 667 "VBNET.ATG" out section); -#line 666 "VBNET.ATG" +#line 667 "VBNET.ATG" attributes.Add(section); } while (StartOf(6)) { MemberModifier( -#line 667 "VBNET.ATG" +#line 668 "VBNET.ATG" m); } ClassMemberDecl( -#line 668 "VBNET.ATG" +#line 669 "VBNET.ATG" m, attributes); } Expect(87); Expect(66); -#line 670 "VBNET.ATG" +#line 671 "VBNET.ATG" newType.EndLocation = t.EndLocation; Expect(1); } void ModuleBody( -#line 689 "VBNET.ATG" +#line 690 "VBNET.ATG" TypeDeclaration newType) { -#line 690 "VBNET.ATG" +#line 691 "VBNET.ATG" AttributeSection section; while (StartOf(5)) { -#line 692 "VBNET.ATG" +#line 693 "VBNET.ATG" ArrayList attributes = new ArrayList(); Modifiers m = new Modifiers(); while (la.kind == 26) { AttributeSection( -#line 695 "VBNET.ATG" +#line 696 "VBNET.ATG" out section); -#line 695 "VBNET.ATG" +#line 696 "VBNET.ATG" attributes.Add(section); } while (StartOf(6)) { MemberModifier( -#line 696 "VBNET.ATG" +#line 697 "VBNET.ATG" m); } ClassMemberDecl( -#line 697 "VBNET.ATG" +#line 698 "VBNET.ATG" m, attributes); } Expect(87); Expect(120); -#line 699 "VBNET.ATG" +#line 700 "VBNET.ATG" newType.EndLocation = t.EndLocation; Expect(1); } void StructureBody( -#line 674 "VBNET.ATG" +#line 675 "VBNET.ATG" TypeDeclaration newType) { -#line 675 "VBNET.ATG" +#line 676 "VBNET.ATG" AttributeSection section; while (StartOf(5)) { -#line 677 "VBNET.ATG" +#line 678 "VBNET.ATG" ArrayList attributes = new ArrayList(); Modifiers m = new Modifiers(); while (la.kind == 26) { AttributeSection( -#line 680 "VBNET.ATG" +#line 681 "VBNET.ATG" out section); -#line 680 "VBNET.ATG" +#line 681 "VBNET.ATG" attributes.Add(section); } while (StartOf(6)) { MemberModifier( -#line 681 "VBNET.ATG" +#line 682 "VBNET.ATG" m); } StructureMemberDecl( -#line 682 "VBNET.ATG" +#line 683 "VBNET.ATG" m, attributes); } Expect(87); Expect(166); -#line 684 "VBNET.ATG" +#line 685 "VBNET.ATG" newType.EndLocation = t.EndLocation; Expect(1); } void PrimitiveTypeName( -#line 2631 "VBNET.ATG" +#line 2632 "VBNET.ATG" out string type) { -#line 2632 "VBNET.ATG" +#line 2633 "VBNET.ATG" type = String.Empty; switch (la.kind) { case 51: { lexer.NextToken(); -#line 2633 "VBNET.ATG" +#line 2634 "VBNET.ATG" type = "Boolean"; break; } case 75: { lexer.NextToken(); -#line 2634 "VBNET.ATG" +#line 2635 "VBNET.ATG" type = "Date"; break; } case 64: { lexer.NextToken(); -#line 2635 "VBNET.ATG" +#line 2636 "VBNET.ATG" type = "Char"; break; } case 165: { lexer.NextToken(); -#line 2636 "VBNET.ATG" +#line 2637 "VBNET.ATG" type = "String"; break; } case 76: { lexer.NextToken(); -#line 2637 "VBNET.ATG" +#line 2638 "VBNET.ATG" type = "Decimal"; break; } case 53: { lexer.NextToken(); -#line 2638 "VBNET.ATG" +#line 2639 "VBNET.ATG" type = "Byte"; break; } case 159: { lexer.NextToken(); -#line 2639 "VBNET.ATG" +#line 2640 "VBNET.ATG" type = "Short"; break; } case 110: { lexer.NextToken(); -#line 2640 "VBNET.ATG" +#line 2641 "VBNET.ATG" type = "Integer"; break; } case 116: { lexer.NextToken(); -#line 2641 "VBNET.ATG" +#line 2642 "VBNET.ATG" type = "Long"; break; } case 160: { lexer.NextToken(); -#line 2642 "VBNET.ATG" +#line 2643 "VBNET.ATG" type = "Single"; break; } case 83: { lexer.NextToken(); -#line 2643 "VBNET.ATG" +#line 2644 "VBNET.ATG" type = "Double"; break; } case 191: { lexer.NextToken(); -#line 2644 "VBNET.ATG" +#line 2645 "VBNET.ATG" type = "UInteger"; break; } case 192: { lexer.NextToken(); -#line 2645 "VBNET.ATG" +#line 2646 "VBNET.ATG" type = "ULong"; break; } case 193: { lexer.NextToken(); -#line 2646 "VBNET.ATG" +#line 2647 "VBNET.ATG" type = "UShort"; break; } case 190: { lexer.NextToken(); -#line 2647 "VBNET.ATG" +#line 2648 "VBNET.ATG" type = "SByte"; break; } @@ -1230,56 +1231,56 @@ out string type) { } void EnumBody( -#line 703 "VBNET.ATG" +#line 704 "VBNET.ATG" TypeDeclaration newType) { -#line 704 "VBNET.ATG" +#line 705 "VBNET.ATG" FieldDeclaration f; while (StartOf(7)) { EnumMemberDecl( -#line 706 "VBNET.ATG" +#line 707 "VBNET.ATG" out f); -#line 706 "VBNET.ATG" +#line 707 "VBNET.ATG" compilationUnit.AddChild(f); } Expect(87); Expect(89); -#line 708 "VBNET.ATG" +#line 709 "VBNET.ATG" newType.EndLocation = t.EndLocation; Expect(1); } void InterfaceBase( -#line 1297 "VBNET.ATG" +#line 1298 "VBNET.ATG" out ArrayList bases) { -#line 1299 "VBNET.ATG" +#line 1300 "VBNET.ATG" TypeReference type; bases = new ArrayList(); Expect(109); TypeName( -#line 1303 "VBNET.ATG" +#line 1304 "VBNET.ATG" out type); -#line 1303 "VBNET.ATG" +#line 1304 "VBNET.ATG" bases.Add(type.Type); while (la.kind == 12) { lexer.NextToken(); TypeName( -#line 1306 "VBNET.ATG" +#line 1307 "VBNET.ATG" out type); -#line 1306 "VBNET.ATG" +#line 1307 "VBNET.ATG" bases.Add(type.Type); } Expect(1); } void InterfaceBody( -#line 712 "VBNET.ATG" +#line 713 "VBNET.ATG" TypeDeclaration newType) { while (StartOf(8)) { InterfaceMemberDecl(); @@ -1287,33 +1288,33 @@ TypeDeclaration newType) { Expect(87); Expect(111); -#line 714 "VBNET.ATG" +#line 715 "VBNET.ATG" newType.EndLocation = t.EndLocation; Expect(1); } void FormalParameterList( -#line 1829 "VBNET.ATG" +#line 1830 "VBNET.ATG" out ArrayList parameter) { -#line 1831 "VBNET.ATG" +#line 1832 "VBNET.ATG" parameter = new ArrayList(); ParameterDeclarationExpression p; AttributeSection section;ArrayList attributes = new ArrayList(); while (la.kind == 26) { AttributeSection( -#line 1835 "VBNET.ATG" +#line 1836 "VBNET.ATG" out section); -#line 1835 "VBNET.ATG" +#line 1836 "VBNET.ATG" attributes.Add(section); } FormalParameter( -#line 1837 "VBNET.ATG" +#line 1838 "VBNET.ATG" out p); -#line 1839 "VBNET.ATG" +#line 1840 "VBNET.ATG" bool paramsFound = false; p.Attributes = attributes; parameter.Add(p); @@ -1321,39 +1322,39 @@ out p); while (la.kind == 12) { lexer.NextToken(); -#line 1844 "VBNET.ATG" +#line 1845 "VBNET.ATG" if (paramsFound) Error("params array must be at end of parameter list"); while (la.kind == 26) { AttributeSection( -#line 1845 "VBNET.ATG" +#line 1846 "VBNET.ATG" out section); -#line 1845 "VBNET.ATG" +#line 1846 "VBNET.ATG" attributes.Add(section); } FormalParameter( -#line 1847 "VBNET.ATG" +#line 1848 "VBNET.ATG" out p); -#line 1847 "VBNET.ATG" +#line 1848 "VBNET.ATG" p.Attributes = attributes; parameter.Add(p); } } void TypeName( -#line 1665 "VBNET.ATG" +#line 1666 "VBNET.ATG" out TypeReference typeref) { -#line 1666 "VBNET.ATG" +#line 1667 "VBNET.ATG" ArrayList rank = null; typeref = null; NonArrayTypeName( -#line 1668 "VBNET.ATG" +#line 1669 "VBNET.ATG" out typeref); ArrayTypeModifiers( -#line 1669 "VBNET.ATG" +#line 1670 "VBNET.ATG" out rank); -#line 1671 "VBNET.ATG" +#line 1672 "VBNET.ATG" if (rank != null) { typeref = new TypeReference(typeref == null ? "UNKNOWN" : typeref.Type, (int[])rank.ToArray(typeof(int))); } @@ -1361,132 +1362,132 @@ out rank); } void MemberModifier( -#line 2669 "VBNET.ATG" +#line 2670 "VBNET.ATG" Modifiers m) { switch (la.kind) { case 121: { lexer.NextToken(); -#line 2670 "VBNET.ATG" +#line 2671 "VBNET.ATG" m.Add(Modifier.Abstract); break; } case 78: { lexer.NextToken(); -#line 2671 "VBNET.ATG" +#line 2672 "VBNET.ATG" m.Add(Modifier.Default); break; } case 98: { lexer.NextToken(); -#line 2672 "VBNET.ATG" +#line 2673 "VBNET.ATG" m.Add(Modifier.Internal); break; } case 157: { lexer.NextToken(); -#line 2673 "VBNET.ATG" +#line 2674 "VBNET.ATG" m.Add(Modifier.New); break; } case 142: { lexer.NextToken(); -#line 2674 "VBNET.ATG" +#line 2675 "VBNET.ATG" m.Add(Modifier.Override); break; } case 122: { lexer.NextToken(); -#line 2675 "VBNET.ATG" +#line 2676 "VBNET.ATG" m.Add(Modifier.Abstract); break; } case 145: { lexer.NextToken(); -#line 2676 "VBNET.ATG" +#line 2677 "VBNET.ATG" m.Add(Modifier.Private); break; } case 147: { lexer.NextToken(); -#line 2677 "VBNET.ATG" +#line 2678 "VBNET.ATG" m.Add(Modifier.Protected); break; } case 148: { lexer.NextToken(); -#line 2678 "VBNET.ATG" +#line 2679 "VBNET.ATG" m.Add(Modifier.Public); break; } case 130: { lexer.NextToken(); -#line 2679 "VBNET.ATG" +#line 2680 "VBNET.ATG" m.Add(Modifier.Sealed); break; } case 131: { lexer.NextToken(); -#line 2680 "VBNET.ATG" +#line 2681 "VBNET.ATG" m.Add(Modifier.Sealed); break; } case 158: { lexer.NextToken(); -#line 2681 "VBNET.ATG" +#line 2682 "VBNET.ATG" m.Add(Modifier.Static); break; } case 140: { lexer.NextToken(); -#line 2682 "VBNET.ATG" +#line 2683 "VBNET.ATG" m.Add(Modifier.Virtual); break; } case 139: { lexer.NextToken(); -#line 2683 "VBNET.ATG" +#line 2684 "VBNET.ATG" m.Add(Modifier.Overloads); break; } case 150: { lexer.NextToken(); -#line 2684 "VBNET.ATG" +#line 2685 "VBNET.ATG" break; } case 184: { lexer.NextToken(); -#line 2685 "VBNET.ATG" +#line 2686 "VBNET.ATG" break; } case 183: { lexer.NextToken(); -#line 2686 "VBNET.ATG" +#line 2687 "VBNET.ATG" m.Add(Modifier.WithEvents); break; } case 80: { lexer.NextToken(); -#line 2687 "VBNET.ATG" +#line 2688 "VBNET.ATG" m.Add(Modifier.Dim); break; } @@ -1495,43 +1496,43 @@ Modifiers m) { } void ClassMemberDecl( -#line 817 "VBNET.ATG" +#line 818 "VBNET.ATG" Modifiers m,ArrayList attributes) { StructureMemberDecl( -#line 818 "VBNET.ATG" +#line 819 "VBNET.ATG" m, attributes); } void StructureMemberDecl( -#line 832 "VBNET.ATG" +#line 833 "VBNET.ATG" Modifiers m, ArrayList attributes) { -#line 834 "VBNET.ATG" +#line 835 "VBNET.ATG" TypeReference type = null; ArrayList p = null; - Statement stmt = null; ArrayList variableDeclarators = new ArrayList(); + Statement stmt = null; List variableDeclarators = new List(); switch (la.kind) { case 66: case 79: case 89: case 111: case 120: case 166: case 197: { NonModuleDeclaration( -#line 837 "VBNET.ATG" +#line 838 "VBNET.ATG" m, attributes); break; } case 167: { lexer.NextToken(); -#line 841 "VBNET.ATG" +#line 842 "VBNET.ATG" Point startPos = t.Location; if (StartOf(9)) { -#line 845 "VBNET.ATG" +#line 846 "VBNET.ATG" string name = String.Empty; MethodDeclaration methodDeclaration; ArrayList handlesClause = null; ArrayList implementsClause = null; Identifier(); -#line 850 "VBNET.ATG" +#line 851 "VBNET.ATG" name = t.val; m.Check(Modifier.VBMethods); @@ -1539,7 +1540,7 @@ m, attributes); lexer.NextToken(); if (StartOf(4)) { FormalParameterList( -#line 853 "VBNET.ATG" +#line 854 "VBNET.ATG" out p); } Expect(24); @@ -1547,23 +1548,23 @@ out p); if (la.kind == 104 || la.kind == 106) { if (la.kind == 106) { ImplementsClause( -#line 856 "VBNET.ATG" +#line 857 "VBNET.ATG" out implementsClause); } else { HandlesClause( -#line 858 "VBNET.ATG" +#line 859 "VBNET.ATG" out handlesClause); } } -#line 861 "VBNET.ATG" +#line 862 "VBNET.ATG" Point endLocation = t.EndLocation; Expect(1); if ( -#line 865 "VBNET.ATG" +#line 866 "VBNET.ATG" IsMustOverride(m)) { -#line 867 "VBNET.ATG" +#line 868 "VBNET.ATG" methodDeclaration = new MethodDeclaration(name, m.Modifier, null, p, attributes); methodDeclaration.StartLocation = startPos; methodDeclaration.EndLocation = endLocation; @@ -1576,7 +1577,7 @@ IsMustOverride(m)) { } else if (StartOf(10)) { -#line 879 "VBNET.ATG" +#line 880 "VBNET.ATG" methodDeclaration = new MethodDeclaration(name, m.Modifier, null, p, attributes); methodDeclaration.StartLocation = startPos; methodDeclaration.EndLocation = endLocation; @@ -1589,17 +1590,17 @@ IsMustOverride(m)) { compilationUnit.BlockStart(methodDeclaration); Block( -#line 890 "VBNET.ATG" +#line 891 "VBNET.ATG" out stmt); -#line 892 "VBNET.ATG" +#line 893 "VBNET.ATG" compilationUnit.BlockEnd(); methodDeclaration.Body = (BlockStatement)stmt; Expect(87); Expect(167); -#line 895 "VBNET.ATG" +#line 896 "VBNET.ATG" methodDeclaration.Body.EndLocation = t.EndLocation; Expect(1); } else SynErr(212); @@ -1609,29 +1610,29 @@ out stmt); lexer.NextToken(); if (StartOf(4)) { FormalParameterList( -#line 898 "VBNET.ATG" +#line 899 "VBNET.ATG" out p); } Expect(24); } -#line 899 "VBNET.ATG" +#line 900 "VBNET.ATG" m.Check(Modifier.Constructors); -#line 900 "VBNET.ATG" +#line 901 "VBNET.ATG" Point constructorEndLocation = t.EndLocation; Expect(1); Block( -#line 902 "VBNET.ATG" +#line 903 "VBNET.ATG" out stmt); Expect(87); Expect(167); -#line 903 "VBNET.ATG" +#line 904 "VBNET.ATG" Point endLocation = t.EndLocation; Expect(1); -#line 905 "VBNET.ATG" +#line 906 "VBNET.ATG" ConstructorDeclaration cd = new ConstructorDeclaration("New", m.Modifier, p, attributes); cd.StartLocation = startPos; cd.EndLocation = constructorEndLocation; @@ -1645,7 +1646,7 @@ out stmt); case 99: { lexer.NextToken(); -#line 917 "VBNET.ATG" +#line 918 "VBNET.ATG" m.Check(Modifier.VBMethods); string name = String.Empty; Point startPos = t.Location; @@ -1654,13 +1655,13 @@ out stmt); Identifier(); -#line 923 "VBNET.ATG" +#line 924 "VBNET.ATG" name = t.val; if (la.kind == 23) { lexer.NextToken(); if (StartOf(4)) { FormalParameterList( -#line 924 "VBNET.ATG" +#line 925 "VBNET.ATG" out p); } Expect(24); @@ -1669,15 +1670,15 @@ out p); lexer.NextToken(); while (la.kind == 26) { AttributeSection( -#line 925 "VBNET.ATG" +#line 926 "VBNET.ATG" out returnTypeAttributeSection); } TypeName( -#line 925 "VBNET.ATG" +#line 926 "VBNET.ATG" out type); } -#line 927 "VBNET.ATG" +#line 928 "VBNET.ATG" if(type == null) { type = new TypeReference("System.Object"); } @@ -1685,20 +1686,20 @@ out type); if (la.kind == 104 || la.kind == 106) { if (la.kind == 106) { ImplementsClause( -#line 933 "VBNET.ATG" +#line 934 "VBNET.ATG" out implementsClause); } else { HandlesClause( -#line 935 "VBNET.ATG" +#line 936 "VBNET.ATG" out handlesClause); } } Expect(1); if ( -#line 941 "VBNET.ATG" +#line 942 "VBNET.ATG" IsMustOverride(m)) { -#line 943 "VBNET.ATG" +#line 944 "VBNET.ATG" methodDeclaration = new MethodDeclaration(name, m.Modifier, type, p, attributes); methodDeclaration.StartLocation = startPos; methodDeclaration.EndLocation = t.EndLocation; @@ -1709,7 +1710,7 @@ IsMustOverride(m)) { } else if (StartOf(10)) { -#line 953 "VBNET.ATG" +#line 954 "VBNET.ATG" methodDeclaration = new MethodDeclaration(name, m.Modifier, type, p, attributes); methodDeclaration.StartLocation = startPos; methodDeclaration.EndLocation = t.EndLocation; @@ -1722,17 +1723,17 @@ IsMustOverride(m)) { compilationUnit.BlockStart(methodDeclaration); Block( -#line 964 "VBNET.ATG" +#line 965 "VBNET.ATG" out stmt); -#line 966 "VBNET.ATG" +#line 967 "VBNET.ATG" compilationUnit.BlockEnd(); methodDeclaration.Body = (BlockStatement)stmt; Expect(87); Expect(99); -#line 971 "VBNET.ATG" +#line 972 "VBNET.ATG" methodDeclaration.Body.StartLocation = methodDeclaration.EndLocation; methodDeclaration.Body.EndLocation = t.EndLocation; @@ -1743,7 +1744,7 @@ out stmt); case 77: { lexer.NextToken(); -#line 980 "VBNET.ATG" +#line 981 "VBNET.ATG" m.Check(Modifier.VBExternalMethods); Point startPos = t.Location; CharsetModifier charsetModifer = CharsetModifier.None; @@ -1753,39 +1754,39 @@ out stmt); if (StartOf(11)) { Charset( -#line 987 "VBNET.ATG" +#line 988 "VBNET.ATG" out charsetModifer); } if (la.kind == 167) { lexer.NextToken(); Identifier(); -#line 990 "VBNET.ATG" +#line 991 "VBNET.ATG" name = t.val; Expect(114); Expect(3); -#line 991 "VBNET.ATG" +#line 992 "VBNET.ATG" library = t.val.ToString(); if (la.kind == 43) { lexer.NextToken(); Expect(3); -#line 992 "VBNET.ATG" +#line 993 "VBNET.ATG" alias = t.val.ToString(); } if (la.kind == 23) { lexer.NextToken(); if (StartOf(4)) { FormalParameterList( -#line 993 "VBNET.ATG" +#line 994 "VBNET.ATG" out p); } Expect(24); } Expect(1); -#line 996 "VBNET.ATG" +#line 997 "VBNET.ATG" DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, null, p, attributes, library, alias, charsetModifer); declareDeclaration.StartLocation = startPos; declareDeclaration.EndLocation = t.EndLocation; @@ -1795,25 +1796,25 @@ out p); lexer.NextToken(); Identifier(); -#line 1003 "VBNET.ATG" +#line 1004 "VBNET.ATG" name = t.val; Expect(114); Expect(3); -#line 1004 "VBNET.ATG" +#line 1005 "VBNET.ATG" library = t.val; if (la.kind == 43) { lexer.NextToken(); Expect(3); -#line 1005 "VBNET.ATG" +#line 1006 "VBNET.ATG" alias = t.val; } if (la.kind == 23) { lexer.NextToken(); if (StartOf(4)) { FormalParameterList( -#line 1006 "VBNET.ATG" +#line 1007 "VBNET.ATG" out p); } Expect(24); @@ -1821,12 +1822,12 @@ out p); if (la.kind == 47) { lexer.NextToken(); TypeName( -#line 1007 "VBNET.ATG" +#line 1008 "VBNET.ATG" out type); } Expect(1); -#line 1010 "VBNET.ATG" +#line 1011 "VBNET.ATG" DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, type, p, attributes, library, alias, charsetModifer); declareDeclaration.StartLocation = startPos; declareDeclaration.EndLocation = t.EndLocation; @@ -1838,7 +1839,7 @@ out type); case 92: { lexer.NextToken(); -#line 1020 "VBNET.ATG" +#line 1021 "VBNET.ATG" m.Check(Modifier.VBEvents); Point startPos = t.Location; EventDeclaration eventDeclaration; @@ -1846,19 +1847,19 @@ out type); Identifier(); -#line 1025 "VBNET.ATG" +#line 1026 "VBNET.ATG" name= t.val; if (la.kind == 47) { lexer.NextToken(); TypeName( -#line 1027 "VBNET.ATG" +#line 1028 "VBNET.ATG" out type); } else if (la.kind == 1 || la.kind == 23 || la.kind == 106) { if (la.kind == 23) { lexer.NextToken(); if (StartOf(4)) { FormalParameterList( -#line 1029 "VBNET.ATG" +#line 1030 "VBNET.ATG" out p); } Expect(24); @@ -1866,11 +1867,11 @@ out p); } else SynErr(216); if (la.kind == 106) { ImplementsClause( -#line 1031 "VBNET.ATG" +#line 1032 "VBNET.ATG" out implementsClause); } -#line 1033 "VBNET.ATG" +#line 1034 "VBNET.ATG" eventDeclaration = new EventDeclaration(type, m.Modifier, p, attributes, name, implementsClause); eventDeclaration.StartLocation = startPos; eventDeclaration.EndLocation = t.EndLocation; @@ -1881,26 +1882,26 @@ out implementsClause); } case 2: case 50: case 69: case 169: { -#line 1040 "VBNET.ATG" +#line 1041 "VBNET.ATG" Point startPos = t.Location; -#line 1042 "VBNET.ATG" +#line 1043 "VBNET.ATG" m.Check(Modifier.Fields); FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier); fd.StartLocation = startPos; VariableDeclarator( -#line 1046 "VBNET.ATG" +#line 1047 "VBNET.ATG" variableDeclarators); while (la.kind == 12) { lexer.NextToken(); VariableDeclarator( -#line 1047 "VBNET.ATG" +#line 1048 "VBNET.ATG" variableDeclarators); } Expect(1); -#line 1050 "VBNET.ATG" +#line 1051 "VBNET.ATG" fd.EndLocation = t.EndLocation; fd.Fields = variableDeclarators; compilationUnit.AddChild(fd); @@ -1909,34 +1910,34 @@ variableDeclarators); } case 70: { -#line 1055 "VBNET.ATG" +#line 1056 "VBNET.ATG" m.Check(Modifier.Fields); lexer.NextToken(); -#line 1056 "VBNET.ATG" +#line 1057 "VBNET.ATG" m.Add(Modifier.Const); -#line 1058 "VBNET.ATG" +#line 1059 "VBNET.ATG" FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier); - fd.StartLocation = t.Location;ArrayList constantDeclarators = new ArrayList(); + fd.StartLocation = t.Location;List constantDeclarators = new List(); ConstantDeclarator( -#line 1061 "VBNET.ATG" +#line 1062 "VBNET.ATG" constantDeclarators); while (la.kind == 12) { lexer.NextToken(); ConstantDeclarator( -#line 1062 "VBNET.ATG" +#line 1063 "VBNET.ATG" constantDeclarators); } -#line 1064 "VBNET.ATG" +#line 1065 "VBNET.ATG" fd.Fields = constantDeclarators; fd.EndLocation = t.Location; Expect(1); -#line 1069 "VBNET.ATG" +#line 1070 "VBNET.ATG" fd.EndLocation = t.EndLocation; compilationUnit.AddChild(fd); @@ -1945,19 +1946,19 @@ constantDeclarators); case 146: { lexer.NextToken(); -#line 1075 "VBNET.ATG" +#line 1076 "VBNET.ATG" m.Check(Modifier.VBProperties); Point startPos = t.Location;ArrayList implementsClause = null; Identifier(); -#line 1078 "VBNET.ATG" +#line 1079 "VBNET.ATG" string propertyName = t.val; if (la.kind == 23) { lexer.NextToken(); if (StartOf(4)) { FormalParameterList( -#line 1079 "VBNET.ATG" +#line 1080 "VBNET.ATG" out p); } Expect(24); @@ -1965,26 +1966,26 @@ out p); if (la.kind == 47) { lexer.NextToken(); TypeName( -#line 1080 "VBNET.ATG" +#line 1081 "VBNET.ATG" out type); } -#line 1082 "VBNET.ATG" +#line 1083 "VBNET.ATG" if(type == null) { type = new TypeReference("System.Object"); } if (la.kind == 106) { ImplementsClause( -#line 1086 "VBNET.ATG" +#line 1087 "VBNET.ATG" out implementsClause); } Expect(1); if ( -#line 1090 "VBNET.ATG" +#line 1091 "VBNET.ATG" IsMustOverride(m)) { -#line 1092 "VBNET.ATG" +#line 1093 "VBNET.ATG" PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes); pDecl.StartLocation = startPos; pDecl.EndLocation = t.Location; @@ -1995,7 +1996,7 @@ IsMustOverride(m)) { } else if (la.kind == 26 || la.kind == 100 || la.kind == 156) { -#line 1102 "VBNET.ATG" +#line 1103 "VBNET.ATG" PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes); pDecl.StartLocation = startPos; pDecl.EndLocation = t.Location; @@ -2007,13 +2008,13 @@ IsMustOverride(m)) { PropertySetRegion setRegion; AccessorDecls( -#line 1112 "VBNET.ATG" +#line 1113 "VBNET.ATG" out getRegion, out setRegion); Expect(87); Expect(146); Expect(1); -#line 1116 "VBNET.ATG" +#line 1117 "VBNET.ATG" pDecl.GetRegion = getRegion; pDecl.SetRegion = setRegion; pDecl.BodyEnd = t.EndLocation; @@ -2027,25 +2028,25 @@ out getRegion, out setRegion); } void EnumMemberDecl( -#line 799 "VBNET.ATG" +#line 800 "VBNET.ATG" out FieldDeclaration f) { -#line 801 "VBNET.ATG" +#line 802 "VBNET.ATG" Expression expr = null;ArrayList attributes = new ArrayList(); AttributeSection section = null; VariableDeclaration varDecl = null; while (la.kind == 26) { AttributeSection( -#line 805 "VBNET.ATG" +#line 806 "VBNET.ATG" out section); -#line 805 "VBNET.ATG" +#line 806 "VBNET.ATG" attributes.Add(section); } Identifier(); -#line 808 "VBNET.ATG" +#line 809 "VBNET.ATG" f = new FieldDeclaration(attributes); varDecl = new VariableDeclaration(t.val); f.Fields.Add(varDecl); @@ -2054,10 +2055,10 @@ out section); if (la.kind == 11) { lexer.NextToken(); Expr( -#line 813 "VBNET.ATG" +#line 814 "VBNET.ATG" out expr); -#line 813 "VBNET.ATG" +#line 814 "VBNET.ATG" varDecl.Initializer = expr; } Expect(1); @@ -2065,7 +2066,7 @@ out expr); void InterfaceMemberDecl() { -#line 724 "VBNET.ATG" +#line 725 "VBNET.ATG" TypeReference type =null;ArrayList p = null; AttributeSection section, returnTypeAttributeSection = null; @@ -2075,31 +2076,31 @@ out expr); if (StartOf(12)) { while (la.kind == 26) { AttributeSection( -#line 730 "VBNET.ATG" +#line 731 "VBNET.ATG" out section); -#line 730 "VBNET.ATG" +#line 731 "VBNET.ATG" attributes.Add(section); } while (StartOf(6)) { MemberModifier( -#line 734 "VBNET.ATG" +#line 735 "VBNET.ATG" mod); } if (la.kind == 92) { lexer.NextToken(); -#line 737 "VBNET.ATG" +#line 738 "VBNET.ATG" mod.Check(Modifier.VBInterfaceEvents); Identifier(); -#line 738 "VBNET.ATG" +#line 739 "VBNET.ATG" name = t.val; if (la.kind == 23) { lexer.NextToken(); if (StartOf(4)) { FormalParameterList( -#line 739 "VBNET.ATG" +#line 740 "VBNET.ATG" out p); } Expect(24); @@ -2107,12 +2108,12 @@ out p); if (la.kind == 47) { lexer.NextToken(); TypeName( -#line 740 "VBNET.ATG" +#line 741 "VBNET.ATG" out type); } Expect(1); -#line 743 "VBNET.ATG" +#line 744 "VBNET.ATG" EventDeclaration ed = new EventDeclaration(type, mod.Modifier, p, attributes, name, null); compilationUnit.AddChild(ed); ed.EndLocation = t.EndLocation; @@ -2120,24 +2121,24 @@ out type); } else if (la.kind == 167) { lexer.NextToken(); -#line 749 "VBNET.ATG" +#line 750 "VBNET.ATG" mod.Check(Modifier.VBInterfaceMethods); Identifier(); -#line 750 "VBNET.ATG" +#line 751 "VBNET.ATG" name = t.val; if (la.kind == 23) { lexer.NextToken(); if (StartOf(4)) { FormalParameterList( -#line 751 "VBNET.ATG" +#line 752 "VBNET.ATG" out p); } Expect(24); } Expect(1); -#line 754 "VBNET.ATG" +#line 755 "VBNET.ATG" MethodDeclaration md = new MethodDeclaration(name, mod.Modifier, null, p, attributes); md.TypeReference = new TypeReference("", "System.Void"); md.EndLocation = t.EndLocation; @@ -2146,17 +2147,17 @@ out p); } else if (la.kind == 99) { lexer.NextToken(); -#line 761 "VBNET.ATG" +#line 762 "VBNET.ATG" mod.Check(Modifier.VBInterfaceMethods); Identifier(); -#line 762 "VBNET.ATG" +#line 763 "VBNET.ATG" name = t.val; if (la.kind == 23) { lexer.NextToken(); if (StartOf(4)) { FormalParameterList( -#line 763 "VBNET.ATG" +#line 764 "VBNET.ATG" out p); } Expect(24); @@ -2165,15 +2166,15 @@ out p); lexer.NextToken(); while (la.kind == 26) { AttributeSection( -#line 764 "VBNET.ATG" +#line 765 "VBNET.ATG" out returnTypeAttributeSection); } TypeName( -#line 764 "VBNET.ATG" +#line 765 "VBNET.ATG" out type); } -#line 766 "VBNET.ATG" +#line 767 "VBNET.ATG" if(type == null) { type = new TypeReference("System.Object"); } @@ -2186,17 +2187,17 @@ out type); } else if (la.kind == 146) { lexer.NextToken(); -#line 777 "VBNET.ATG" +#line 778 "VBNET.ATG" mod.Check(Modifier.VBInterfaceProperties); Identifier(); -#line 778 "VBNET.ATG" +#line 779 "VBNET.ATG" name = t.val; if (la.kind == 23) { lexer.NextToken(); if (StartOf(4)) { FormalParameterList( -#line 779 "VBNET.ATG" +#line 780 "VBNET.ATG" out p); } Expect(24); @@ -2204,18 +2205,18 @@ out p); if (la.kind == 47) { lexer.NextToken(); TypeName( -#line 780 "VBNET.ATG" +#line 781 "VBNET.ATG" out type); } -#line 782 "VBNET.ATG" +#line 783 "VBNET.ATG" if(type == null) { type = new TypeReference("System.Object"); } Expect(1); -#line 788 "VBNET.ATG" +#line 789 "VBNET.ATG" PropertyDeclaration pd = new PropertyDeclaration(name, type, mod.Modifier, attributes); pd.Parameters = p; pd.EndLocation = t.EndLocation; @@ -2224,24 +2225,24 @@ out type); } else SynErr(219); } else if (StartOf(13)) { NonModuleDeclaration( -#line 795 "VBNET.ATG" +#line 796 "VBNET.ATG" mod, attributes); } else SynErr(220); } void Expr( -#line 1351 "VBNET.ATG" +#line 1352 "VBNET.ATG" out Expression expr) { ConditionalOrExpr( -#line 1353 "VBNET.ATG" +#line 1354 "VBNET.ATG" out expr); } void ImplementsClause( -#line 1329 "VBNET.ATG" +#line 1330 "VBNET.ATG" out ArrayList baseInterfaces) { -#line 1331 "VBNET.ATG" +#line 1332 "VBNET.ATG" baseInterfaces = new ArrayList(); string typename = String.Empty; string first; @@ -2249,76 +2250,76 @@ out ArrayList baseInterfaces) { Expect(106); Identifier(); -#line 1335 "VBNET.ATG" +#line 1336 "VBNET.ATG" first = t.val; Expect(10); Qualident( -#line 1335 "VBNET.ATG" +#line 1336 "VBNET.ATG" out typename); -#line 1335 "VBNET.ATG" +#line 1336 "VBNET.ATG" baseInterfaces.Add(first + "." + typename); while (la.kind == 12) { lexer.NextToken(); Identifier(); -#line 1336 "VBNET.ATG" +#line 1337 "VBNET.ATG" first = t.val; Expect(10); Qualident( -#line 1336 "VBNET.ATG" +#line 1337 "VBNET.ATG" out typename); -#line 1336 "VBNET.ATG" +#line 1337 "VBNET.ATG" baseInterfaces.Add(first + "." + typename); } } void HandlesClause( -#line 1287 "VBNET.ATG" +#line 1288 "VBNET.ATG" out ArrayList handlesClause) { -#line 1289 "VBNET.ATG" +#line 1290 "VBNET.ATG" handlesClause = new ArrayList(); string name; Expect(104); EventMemberSpecifier( -#line 1292 "VBNET.ATG" +#line 1293 "VBNET.ATG" out name); -#line 1292 "VBNET.ATG" +#line 1293 "VBNET.ATG" handlesClause.Add(name); while (la.kind == 12) { lexer.NextToken(); EventMemberSpecifier( -#line 1293 "VBNET.ATG" +#line 1294 "VBNET.ATG" out name); -#line 1293 "VBNET.ATG" +#line 1294 "VBNET.ATG" handlesClause.Add(name); } } void Block( -#line 1885 "VBNET.ATG" +#line 1886 "VBNET.ATG" out Statement stmt) { -#line 1888 "VBNET.ATG" +#line 1889 "VBNET.ATG" BlockStatement blockStmt = new BlockStatement(); blockStmt.StartLocation = t.Location; compilationUnit.BlockStart(blockStmt); while (StartOf(14) || -#line 1893 "VBNET.ATG" +#line 1894 "VBNET.ATG" IsEndStmtAhead()) { if ( -#line 1893 "VBNET.ATG" +#line 1894 "VBNET.ATG" IsEndStmtAhead()) { Expect(87); EndOfStmt(); -#line 1893 "VBNET.ATG" +#line 1894 "VBNET.ATG" compilationUnit.AddChild(new EndStatement()); } else { Statement(); @@ -2326,7 +2327,7 @@ IsEndStmtAhead()) { } } -#line 1899 "VBNET.ATG" +#line 1900 "VBNET.ATG" stmt = blockStmt; blockStmt.EndLocation = t.EndLocation; compilationUnit.BlockEnd(); @@ -2334,65 +2335,65 @@ IsEndStmtAhead()) { } void Charset( -#line 1279 "VBNET.ATG" +#line 1280 "VBNET.ATG" out CharsetModifier charsetModifier) { -#line 1280 "VBNET.ATG" +#line 1281 "VBNET.ATG" charsetModifier = CharsetModifier.None; if (la.kind == 99 || la.kind == 167) { } else if (la.kind == 46) { lexer.NextToken(); -#line 1281 "VBNET.ATG" +#line 1282 "VBNET.ATG" charsetModifier = CharsetModifier.ANSI; } else if (la.kind == 49) { lexer.NextToken(); -#line 1282 "VBNET.ATG" +#line 1283 "VBNET.ATG" charsetModifier = CharsetModifier.Auto; } else if (la.kind == 176) { lexer.NextToken(); -#line 1283 "VBNET.ATG" +#line 1284 "VBNET.ATG" charsetModifier = CharsetModifier.Unicode; } else SynErr(221); } void VariableDeclarator( -#line 1197 "VBNET.ATG" -ArrayList fieldDeclaration) { +#line 1198 "VBNET.ATG" +List fieldDeclaration) { -#line 1199 "VBNET.ATG" +#line 1200 "VBNET.ATG" Expression expr = null; TypeReference type = null;ArrayList rank = null;ArrayList dimension = null; Identifier(); -#line 1202 "VBNET.ATG" +#line 1203 "VBNET.ATG" string name = t.val; if ( -#line 1203 "VBNET.ATG" +#line 1204 "VBNET.ATG" IsDims()) { ArrayNameModifier( -#line 1203 "VBNET.ATG" +#line 1204 "VBNET.ATG" out rank); } if ( -#line 1204 "VBNET.ATG" +#line 1205 "VBNET.ATG" IsSize()) { ArrayInitializationModifier( -#line 1204 "VBNET.ATG" +#line 1205 "VBNET.ATG" out dimension); } if ( -#line 1206 "VBNET.ATG" +#line 1207 "VBNET.ATG" IsObjectCreation()) { Expect(47); ObjectCreateExpression( -#line 1206 "VBNET.ATG" +#line 1207 "VBNET.ATG" out expr); -#line 1208 "VBNET.ATG" +#line 1209 "VBNET.ATG" if (expr is ObjectCreateExpression) { type = ((ObjectCreateExpression)expr).CreateType; } else { @@ -2403,11 +2404,11 @@ out expr); if (la.kind == 47) { lexer.NextToken(); TypeName( -#line 1215 "VBNET.ATG" +#line 1216 "VBNET.ATG" out type); } -#line 1217 "VBNET.ATG" +#line 1218 "VBNET.ATG" if (type != null && rank != null) { if(type.RankSpecifier != null) { Error("array rank only allowed one time"); @@ -2419,40 +2420,40 @@ out type); if (la.kind == 11) { lexer.NextToken(); VariableInitializer( -#line 1225 "VBNET.ATG" +#line 1226 "VBNET.ATG" out expr); } } else SynErr(222); -#line 1227 "VBNET.ATG" +#line 1228 "VBNET.ATG" fieldDeclaration.Add(new VariableDeclaration(name, expr, type)); } void ConstantDeclarator( -#line 1180 "VBNET.ATG" -ArrayList constantDeclaration) { +#line 1181 "VBNET.ATG" +List constantDeclaration) { -#line 1182 "VBNET.ATG" +#line 1183 "VBNET.ATG" Expression expr = null; TypeReference type = null; string name = String.Empty; Identifier(); -#line 1186 "VBNET.ATG" +#line 1187 "VBNET.ATG" name = t.val; if (la.kind == 47) { lexer.NextToken(); TypeName( -#line 1187 "VBNET.ATG" +#line 1188 "VBNET.ATG" out type); } Expect(11); Expr( -#line 1188 "VBNET.ATG" +#line 1189 "VBNET.ATG" out expr); -#line 1190 "VBNET.ATG" +#line 1191 "VBNET.ATG" VariableDeclaration f = new VariableDeclaration(name, expr); f.TypeReference = type; constantDeclaration.Add(f); @@ -2460,10 +2461,10 @@ out expr); } void AccessorDecls( -#line 1125 "VBNET.ATG" +#line 1126 "VBNET.ATG" out PropertyGetRegion getBlock, out PropertySetRegion setBlock) { -#line 1126 "VBNET.ATG" +#line 1127 "VBNET.ATG" ArrayList attributes = new ArrayList(); AttributeSection section; getBlock = null; @@ -2471,68 +2472,68 @@ out PropertyGetRegion getBlock, out PropertySetRegion setBlock) { while (la.kind == 26) { AttributeSection( -#line 1131 "VBNET.ATG" +#line 1132 "VBNET.ATG" out section); -#line 1131 "VBNET.ATG" +#line 1132 "VBNET.ATG" attributes.Add(section); } if (la.kind == 100) { GetAccessorDecl( -#line 1133 "VBNET.ATG" +#line 1134 "VBNET.ATG" out getBlock, attributes); if (la.kind == 26 || la.kind == 156) { -#line 1135 "VBNET.ATG" +#line 1136 "VBNET.ATG" attributes = new ArrayList(); while (la.kind == 26) { AttributeSection( -#line 1136 "VBNET.ATG" +#line 1137 "VBNET.ATG" out section); -#line 1136 "VBNET.ATG" +#line 1137 "VBNET.ATG" attributes.Add(section); } SetAccessorDecl( -#line 1137 "VBNET.ATG" +#line 1138 "VBNET.ATG" out setBlock, attributes); } } else if (la.kind == 156) { SetAccessorDecl( -#line 1140 "VBNET.ATG" +#line 1141 "VBNET.ATG" out setBlock, attributes); if (la.kind == 26 || la.kind == 100) { -#line 1142 "VBNET.ATG" +#line 1143 "VBNET.ATG" attributes = new ArrayList(); while (la.kind == 26) { AttributeSection( -#line 1143 "VBNET.ATG" +#line 1144 "VBNET.ATG" out section); -#line 1143 "VBNET.ATG" +#line 1144 "VBNET.ATG" attributes.Add(section); } GetAccessorDecl( -#line 1144 "VBNET.ATG" +#line 1145 "VBNET.ATG" out getBlock, attributes); } } else SynErr(223); } void GetAccessorDecl( -#line 1150 "VBNET.ATG" +#line 1151 "VBNET.ATG" out PropertyGetRegion getBlock,ArrayList attributes) { -#line 1151 "VBNET.ATG" +#line 1152 "VBNET.ATG" Statement stmt = null; Expect(100); Expect(1); Block( -#line 1154 "VBNET.ATG" +#line 1155 "VBNET.ATG" out stmt); -#line 1156 "VBNET.ATG" +#line 1157 "VBNET.ATG" getBlock = new PropertyGetRegion((BlockStatement)stmt, attributes); Expect(87); @@ -2541,10 +2542,10 @@ out stmt); } void SetAccessorDecl( -#line 1163 "VBNET.ATG" +#line 1164 "VBNET.ATG" out PropertySetRegion setBlock,ArrayList attributes) { -#line 1165 "VBNET.ATG" +#line 1166 "VBNET.ATG" Statement stmt = null;ArrayList p = null; Expect(156); @@ -2552,17 +2553,17 @@ out PropertySetRegion setBlock,ArrayList attributes) { lexer.NextToken(); if (StartOf(4)) { FormalParameterList( -#line 1168 "VBNET.ATG" +#line 1169 "VBNET.ATG" out p); } Expect(24); } Expect(1); Block( -#line 1170 "VBNET.ATG" +#line 1171 "VBNET.ATG" out stmt); -#line 1172 "VBNET.ATG" +#line 1173 "VBNET.ATG" setBlock = new PropertySetRegion((BlockStatement)stmt, attributes); setBlock.Parameters = p; @@ -2572,60 +2573,60 @@ out stmt); } void ArrayNameModifier( -#line 1689 "VBNET.ATG" +#line 1690 "VBNET.ATG" out ArrayList arrayModifiers) { -#line 1691 "VBNET.ATG" +#line 1692 "VBNET.ATG" arrayModifiers = null; ArrayTypeModifiers( -#line 1693 "VBNET.ATG" +#line 1694 "VBNET.ATG" out arrayModifiers); } void ArrayInitializationModifier( -#line 1231 "VBNET.ATG" +#line 1232 "VBNET.ATG" out ArrayList arrayModifiers) { -#line 1233 "VBNET.ATG" +#line 1234 "VBNET.ATG" arrayModifiers = null; Expect(23); InitializationRankList( -#line 1235 "VBNET.ATG" +#line 1236 "VBNET.ATG" out arrayModifiers); Expect(24); } void ObjectCreateExpression( -#line 1605 "VBNET.ATG" +#line 1606 "VBNET.ATG" out Expression oce) { -#line 1607 "VBNET.ATG" +#line 1608 "VBNET.ATG" TypeReference type = null; Expression initializer = null;ArrayList arguments = null; oce = null; Expect(126); TypeNameWithoutRank( -#line 1611 "VBNET.ATG" +#line 1612 "VBNET.ATG" out type); if (la.kind == 23) { lexer.NextToken(); if (StartOf(16)) { ArgumentList( -#line 1612 "VBNET.ATG" +#line 1613 "VBNET.ATG" out arguments); } Expect(24); } if (la.kind == 21) { ArrayInitializer( -#line 1613 "VBNET.ATG" +#line 1614 "VBNET.ATG" out initializer); } -#line 1615 "VBNET.ATG" +#line 1616 "VBNET.ATG" if (initializer == null) { oce = new ObjectCreateExpression(type, arguments); } else { @@ -2637,98 +2638,98 @@ out initializer); } void VariableInitializer( -#line 1251 "VBNET.ATG" +#line 1252 "VBNET.ATG" out Expression initializerExpression) { -#line 1253 "VBNET.ATG" +#line 1254 "VBNET.ATG" initializerExpression = null; if (StartOf(17)) { Expr( -#line 1255 "VBNET.ATG" +#line 1256 "VBNET.ATG" out initializerExpression); } else if (la.kind == 21) { ArrayInitializer( -#line 1256 "VBNET.ATG" +#line 1257 "VBNET.ATG" out initializerExpression); } else SynErr(224); } void InitializationRankList( -#line 1239 "VBNET.ATG" +#line 1240 "VBNET.ATG" out ArrayList rank) { -#line 1241 "VBNET.ATG" +#line 1242 "VBNET.ATG" rank = null; Expression expr = null; Expr( -#line 1244 "VBNET.ATG" +#line 1245 "VBNET.ATG" out expr); -#line 1244 "VBNET.ATG" +#line 1245 "VBNET.ATG" rank = new ArrayList(); if (expr != null) { rank.Add(expr); } while (la.kind == 12) { lexer.NextToken(); Expr( -#line 1246 "VBNET.ATG" +#line 1247 "VBNET.ATG" out expr); -#line 1246 "VBNET.ATG" +#line 1247 "VBNET.ATG" if (expr != null) { rank.Add(expr); } } } void ArrayInitializer( -#line 1260 "VBNET.ATG" +#line 1261 "VBNET.ATG" out Expression outExpr) { -#line 1262 "VBNET.ATG" +#line 1263 "VBNET.ATG" Expression expr = null; ArrayInitializerExpression initializer = new ArrayInitializerExpression(); Expect(21); if (StartOf(18)) { VariableInitializer( -#line 1267 "VBNET.ATG" +#line 1268 "VBNET.ATG" out expr); -#line 1269 "VBNET.ATG" +#line 1270 "VBNET.ATG" if (expr != null) { initializer.CreateExpressions.Add(expr); } while ( -#line 1272 "VBNET.ATG" +#line 1273 "VBNET.ATG" NotFinalComma()) { Expect(12); VariableInitializer( -#line 1272 "VBNET.ATG" +#line 1273 "VBNET.ATG" out expr); -#line 1273 "VBNET.ATG" +#line 1274 "VBNET.ATG" if (expr != null) { initializer.CreateExpressions.Add(expr); } } } Expect(22); -#line 1276 "VBNET.ATG" +#line 1277 "VBNET.ATG" outExpr = initializer; } void EventMemberSpecifier( -#line 1339 "VBNET.ATG" +#line 1340 "VBNET.ATG" out string name) { -#line 1340 "VBNET.ATG" +#line 1341 "VBNET.ATG" string type; name = String.Empty; if (StartOf(9)) { Identifier(); -#line 1341 "VBNET.ATG" +#line 1342 "VBNET.ATG" type = t.val; Expect(10); Identifier(); -#line 1343 "VBNET.ATG" +#line 1344 "VBNET.ATG" name = type + "." + t.val; } else if (la.kind == 123) { lexer.NextToken(); @@ -2736,42 +2737,42 @@ out string name) { if (StartOf(9)) { Identifier(); -#line 1346 "VBNET.ATG" +#line 1347 "VBNET.ATG" name = "MyBase." + t.val; } else if (la.kind == 91) { lexer.NextToken(); -#line 1347 "VBNET.ATG" +#line 1348 "VBNET.ATG" name = "MyBase.Error"; } else SynErr(225); } else SynErr(226); } void ConditionalOrExpr( -#line 1484 "VBNET.ATG" +#line 1485 "VBNET.ATG" out Expression outExpr) { -#line 1485 "VBNET.ATG" +#line 1486 "VBNET.ATG" Expression expr; ConditionalAndExpr( -#line 1486 "VBNET.ATG" +#line 1487 "VBNET.ATG" out outExpr); while (la.kind == 138) { lexer.NextToken(); ConditionalAndExpr( -#line 1486 "VBNET.ATG" +#line 1487 "VBNET.ATG" out expr); -#line 1486 "VBNET.ATG" +#line 1487 "VBNET.ATG" outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.LogicalOr, expr); } } void UnaryExpr( -#line 1360 "VBNET.ATG" +#line 1361 "VBNET.ATG" out Expression uExpr) { -#line 1362 "VBNET.ATG" +#line 1363 "VBNET.ATG" Expression expr; UnaryOperatorType uop = UnaryOperatorType.None; bool isUOp = false; @@ -2780,25 +2781,25 @@ out Expression uExpr) { if (la.kind == 14) { lexer.NextToken(); -#line 1366 "VBNET.ATG" +#line 1367 "VBNET.ATG" uop = UnaryOperatorType.Plus; isUOp = true; } else if (la.kind == 15) { lexer.NextToken(); -#line 1367 "VBNET.ATG" +#line 1368 "VBNET.ATG" uop = UnaryOperatorType.Minus; isUOp = true; } else { lexer.NextToken(); -#line 1369 "VBNET.ATG" +#line 1370 "VBNET.ATG" uop = UnaryOperatorType.Star; isUOp = true; } } SimpleExpr( -#line 1371 "VBNET.ATG" +#line 1372 "VBNET.ATG" out expr); -#line 1373 "VBNET.ATG" +#line 1374 "VBNET.ATG" if (isUOp) { uExpr = new UnaryOperatorExpression(expr, uop); } else { @@ -2808,10 +2809,10 @@ out expr); } void SimpleExpr( -#line 1396 "VBNET.ATG" +#line 1397 "VBNET.ATG" out Expression pexpr) { -#line 1398 "VBNET.ATG" +#line 1399 "VBNET.ATG" Expression expr; TypeReference type = null; string name = String.Empty; @@ -2822,142 +2823,142 @@ out Expression pexpr) { case 3: { lexer.NextToken(); -#line 1406 "VBNET.ATG" +#line 1407 "VBNET.ATG" pexpr = new PrimitiveExpression(t.literalValue, t.val); break; } case 4: { lexer.NextToken(); -#line 1407 "VBNET.ATG" +#line 1408 "VBNET.ATG" pexpr = new PrimitiveExpression(t.literalValue, t.val); break; } case 7: { lexer.NextToken(); -#line 1408 "VBNET.ATG" +#line 1409 "VBNET.ATG" pexpr = new PrimitiveExpression(t.literalValue, t.val); break; } case 6: { lexer.NextToken(); -#line 1409 "VBNET.ATG" +#line 1410 "VBNET.ATG" pexpr = new PrimitiveExpression(t.literalValue, t.val); break; } case 5: { lexer.NextToken(); -#line 1410 "VBNET.ATG" +#line 1411 "VBNET.ATG" pexpr = new PrimitiveExpression(t.literalValue, t.val); break; } case 9: { lexer.NextToken(); -#line 1411 "VBNET.ATG" +#line 1412 "VBNET.ATG" pexpr = new PrimitiveExpression(t.literalValue, t.val); break; } case 8: { lexer.NextToken(); -#line 1412 "VBNET.ATG" +#line 1413 "VBNET.ATG" pexpr = new PrimitiveExpression(t.literalValue, t.val); break; } case 173: { lexer.NextToken(); -#line 1414 "VBNET.ATG" +#line 1415 "VBNET.ATG" pexpr = new PrimitiveExpression(true, "true"); break; } case 95: { lexer.NextToken(); -#line 1415 "VBNET.ATG" +#line 1416 "VBNET.ATG" pexpr = new PrimitiveExpression(false, "false"); break; } case 129: { lexer.NextToken(); -#line 1416 "VBNET.ATG" +#line 1417 "VBNET.ATG" pexpr = new PrimitiveExpression(null, "null"); break; } case 23: { lexer.NextToken(); Expr( -#line 1417 "VBNET.ATG" +#line 1418 "VBNET.ATG" out expr); Expect(24); -#line 1417 "VBNET.ATG" +#line 1418 "VBNET.ATG" pexpr = new ParenthesizedExpression(expr); break; } case 2: case 50: case 69: case 169: { Identifier(); -#line 1418 "VBNET.ATG" +#line 1419 "VBNET.ATG" pexpr = new IdentifierExpression(t.val); break; } case 51: case 53: case 64: case 75: case 76: case 83: case 110: case 116: case 159: case 160: case 165: case 190: case 191: case 192: case 193: { -#line 1419 "VBNET.ATG" +#line 1420 "VBNET.ATG" string val = String.Empty; PrimitiveTypeName( -#line 1419 "VBNET.ATG" +#line 1420 "VBNET.ATG" out val); Expect(10); Identifier(); -#line 1420 "VBNET.ATG" +#line 1421 "VBNET.ATG" pexpr = new FieldReferenceExpression(new TypeReferenceExpression(val), t.val); break; } case 118: { lexer.NextToken(); -#line 1421 "VBNET.ATG" +#line 1422 "VBNET.ATG" pexpr = new ThisReferenceExpression(); break; } case 123: case 124: { -#line 1422 "VBNET.ATG" +#line 1423 "VBNET.ATG" Expression retExpr = null; if (la.kind == 123) { lexer.NextToken(); -#line 1423 "VBNET.ATG" +#line 1424 "VBNET.ATG" retExpr = new BaseReferenceExpression(); } else if (la.kind == 124) { lexer.NextToken(); -#line 1424 "VBNET.ATG" +#line 1425 "VBNET.ATG" retExpr = new ClassReferenceExpression(); } else SynErr(227); Expect(10); IdentifierOrKeyword( -#line 1426 "VBNET.ATG" +#line 1427 "VBNET.ATG" out name); -#line 1426 "VBNET.ATG" +#line 1427 "VBNET.ATG" pexpr = new FieldReferenceExpression(retExpr, name); break; } case 126: { ObjectCreateExpression( -#line 1427 "VBNET.ATG" +#line 1428 "VBNET.ATG" out expr); -#line 1427 "VBNET.ATG" +#line 1428 "VBNET.ATG" pexpr = expr; break; } @@ -2969,39 +2970,39 @@ out expr); } else SynErr(228); Expect(23); Expr( -#line 1428 "VBNET.ATG" +#line 1429 "VBNET.ATG" out expr); Expect(12); TypeName( -#line 1428 "VBNET.ATG" +#line 1429 "VBNET.ATG" out type); Expect(24); -#line 1428 "VBNET.ATG" +#line 1429 "VBNET.ATG" pexpr = new CastExpression(type, expr); break; } case 58: case 59: case 60: case 61: case 62: case 63: case 65: case 67: case 68: case 71: case 72: case 73: { CastTarget( -#line 1429 "VBNET.ATG" +#line 1430 "VBNET.ATG" out type); Expect(23); Expr( -#line 1429 "VBNET.ATG" +#line 1430 "VBNET.ATG" out expr); Expect(24); -#line 1429 "VBNET.ATG" +#line 1430 "VBNET.ATG" pexpr = new CastExpression(type, expr, true); break; } case 42: { lexer.NextToken(); Expr( -#line 1430 "VBNET.ATG" +#line 1431 "VBNET.ATG" out expr); -#line 1430 "VBNET.ATG" +#line 1431 "VBNET.ATG" pexpr = new AddressOfExpression(expr); break; } @@ -3009,25 +3010,25 @@ out expr); lexer.NextToken(); Expect(23); TypeName( -#line 1431 "VBNET.ATG" +#line 1432 "VBNET.ATG" out type); Expect(24); -#line 1431 "VBNET.ATG" +#line 1432 "VBNET.ATG" pexpr = new TypeOfExpression(type); break; } case 175: { lexer.NextToken(); SimpleExpr( -#line 1432 "VBNET.ATG" +#line 1433 "VBNET.ATG" out expr); Expect(112); TypeName( -#line 1432 "VBNET.ATG" +#line 1433 "VBNET.ATG" out type); -#line 1432 "VBNET.ATG" +#line 1433 "VBNET.ATG" pexpr = new TypeOfIsExpression(expr, type); break; } @@ -3036,95 +3037,95 @@ out type); if (la.kind == 10) { lexer.NextToken(); IdentifierOrKeyword( -#line 1435 "VBNET.ATG" +#line 1436 "VBNET.ATG" out name); -#line 1435 "VBNET.ATG" +#line 1436 "VBNET.ATG" pexpr = new FieldReferenceExpression(pexpr, name); } else { lexer.NextToken(); -#line 1436 "VBNET.ATG" +#line 1437 "VBNET.ATG" ArrayList parameters = new ArrayList(); if (StartOf(20)) { if (StartOf(17)) { Argument( -#line 1438 "VBNET.ATG" +#line 1439 "VBNET.ATG" out expr); -#line 1438 "VBNET.ATG" +#line 1439 "VBNET.ATG" if (expr != null) { parameters.Add(expr); } } while (la.kind == 12) { lexer.NextToken(); if (StartOf(17)) { Argument( -#line 1441 "VBNET.ATG" +#line 1442 "VBNET.ATG" out expr); -#line 1441 "VBNET.ATG" +#line 1442 "VBNET.ATG" if (expr != null) { parameters.Add(expr); } } } } Expect(24); -#line 1444 "VBNET.ATG" +#line 1445 "VBNET.ATG" pexpr = new InvocationExpression(pexpr, parameters); } } } else if (la.kind == 10) { lexer.NextToken(); IdentifierOrKeyword( -#line 1448 "VBNET.ATG" +#line 1449 "VBNET.ATG" out name); -#line 1448 "VBNET.ATG" +#line 1449 "VBNET.ATG" pexpr = new FieldReferenceExpression(pexpr, name); while (la.kind == 10 || la.kind == 23) { if (la.kind == 10) { lexer.NextToken(); IdentifierOrKeyword( -#line 1450 "VBNET.ATG" +#line 1451 "VBNET.ATG" out name); -#line 1450 "VBNET.ATG" +#line 1451 "VBNET.ATG" pexpr = new FieldReferenceExpression(pexpr, name); } else { lexer.NextToken(); -#line 1451 "VBNET.ATG" +#line 1452 "VBNET.ATG" ArrayList parameters = new ArrayList(); if (StartOf(20)) { -#line 1453 "VBNET.ATG" +#line 1454 "VBNET.ATG" expr = null; if (StartOf(17)) { Argument( -#line 1453 "VBNET.ATG" +#line 1454 "VBNET.ATG" out expr); } -#line 1453 "VBNET.ATG" +#line 1454 "VBNET.ATG" if (expr != null) { parameters.Add(expr); } while (la.kind == 12) { lexer.NextToken(); -#line 1455 "VBNET.ATG" +#line 1456 "VBNET.ATG" expr = null; if (StartOf(17)) { Argument( -#line 1456 "VBNET.ATG" +#line 1457 "VBNET.ATG" out expr); } -#line 1456 "VBNET.ATG" +#line 1457 "VBNET.ATG" if (expr != null) { parameters.Add(expr); } } } Expect(24); -#line 1459 "VBNET.ATG" +#line 1460 "VBNET.ATG" pexpr = new InvocationExpression(pexpr, parameters); } } @@ -3132,79 +3133,79 @@ out expr); } void AssignmentOperator( -#line 1381 "VBNET.ATG" +#line 1382 "VBNET.ATG" out AssignmentOperatorType op) { -#line 1382 "VBNET.ATG" +#line 1383 "VBNET.ATG" op = AssignmentOperatorType.None; switch (la.kind) { case 11: { lexer.NextToken(); -#line 1383 "VBNET.ATG" +#line 1384 "VBNET.ATG" op = AssignmentOperatorType.Assign; break; } case 40: { lexer.NextToken(); -#line 1384 "VBNET.ATG" +#line 1385 "VBNET.ATG" op = AssignmentOperatorType.ConcatString; break; } case 32: { lexer.NextToken(); -#line 1385 "VBNET.ATG" +#line 1386 "VBNET.ATG" op = AssignmentOperatorType.Add; break; } case 34: { lexer.NextToken(); -#line 1386 "VBNET.ATG" +#line 1387 "VBNET.ATG" op = AssignmentOperatorType.Subtract; break; } case 35: { lexer.NextToken(); -#line 1387 "VBNET.ATG" +#line 1388 "VBNET.ATG" op = AssignmentOperatorType.Multiply; break; } case 36: { lexer.NextToken(); -#line 1388 "VBNET.ATG" +#line 1389 "VBNET.ATG" op = AssignmentOperatorType.Divide; break; } case 37: { lexer.NextToken(); -#line 1389 "VBNET.ATG" +#line 1390 "VBNET.ATG" op = AssignmentOperatorType.DivideInteger; break; } case 33: { lexer.NextToken(); -#line 1390 "VBNET.ATG" +#line 1391 "VBNET.ATG" op = AssignmentOperatorType.Power; break; } case 38: { lexer.NextToken(); -#line 1391 "VBNET.ATG" +#line 1392 "VBNET.ATG" op = AssignmentOperatorType.ShiftLeft; break; } case 39: { lexer.NextToken(); -#line 1392 "VBNET.ATG" +#line 1393 "VBNET.ATG" op = AssignmentOperatorType.ShiftRight; break; } @@ -3213,1074 +3214,1074 @@ out AssignmentOperatorType op) { } void IdentifierOrKeyword( -#line 2470 "VBNET.ATG" +#line 2471 "VBNET.ATG" out string name) { -#line 2472 "VBNET.ATG" +#line 2473 "VBNET.ATG" name = String.Empty; switch (la.kind) { case 2: case 50: case 69: case 169: { Identifier(); -#line 2475 "VBNET.ATG" +#line 2476 "VBNET.ATG" name = t.val; break; } case 41: { lexer.NextToken(); -#line 2476 "VBNET.ATG" +#line 2477 "VBNET.ATG" name = t.val; break; } case 42: { lexer.NextToken(); -#line 2477 "VBNET.ATG" +#line 2478 "VBNET.ATG" name = t.val; break; } case 43: { lexer.NextToken(); -#line 2478 "VBNET.ATG" +#line 2479 "VBNET.ATG" name = t.val; break; } case 44: { lexer.NextToken(); -#line 2479 "VBNET.ATG" +#line 2480 "VBNET.ATG" name = t.val; break; } case 45: { lexer.NextToken(); -#line 2480 "VBNET.ATG" +#line 2481 "VBNET.ATG" name = t.val; break; } case 46: { lexer.NextToken(); -#line 2481 "VBNET.ATG" +#line 2482 "VBNET.ATG" name = t.val; break; } case 47: { lexer.NextToken(); -#line 2482 "VBNET.ATG" +#line 2483 "VBNET.ATG" name = t.val; break; } case 48: { lexer.NextToken(); -#line 2483 "VBNET.ATG" +#line 2484 "VBNET.ATG" name = t.val; break; } case 49: { lexer.NextToken(); -#line 2484 "VBNET.ATG" +#line 2485 "VBNET.ATG" name = t.val; break; } case 51: { lexer.NextToken(); -#line 2485 "VBNET.ATG" +#line 2486 "VBNET.ATG" name = t.val; break; } case 52: { lexer.NextToken(); -#line 2486 "VBNET.ATG" +#line 2487 "VBNET.ATG" name = t.val; break; } case 53: { lexer.NextToken(); -#line 2487 "VBNET.ATG" +#line 2488 "VBNET.ATG" name = t.val; break; } case 54: { lexer.NextToken(); -#line 2488 "VBNET.ATG" +#line 2489 "VBNET.ATG" name = t.val; break; } case 55: { lexer.NextToken(); -#line 2489 "VBNET.ATG" +#line 2490 "VBNET.ATG" name = t.val; break; } case 56: { lexer.NextToken(); -#line 2490 "VBNET.ATG" +#line 2491 "VBNET.ATG" name = t.val; break; } case 57: { lexer.NextToken(); -#line 2491 "VBNET.ATG" +#line 2492 "VBNET.ATG" name = t.val; break; } case 58: { lexer.NextToken(); -#line 2492 "VBNET.ATG" +#line 2493 "VBNET.ATG" name = t.val; break; } case 59: { lexer.NextToken(); -#line 2493 "VBNET.ATG" +#line 2494 "VBNET.ATG" name = t.val; break; } case 60: { lexer.NextToken(); -#line 2494 "VBNET.ATG" +#line 2495 "VBNET.ATG" name = t.val; break; } case 61: { lexer.NextToken(); -#line 2495 "VBNET.ATG" +#line 2496 "VBNET.ATG" name = t.val; break; } case 62: { lexer.NextToken(); -#line 2496 "VBNET.ATG" +#line 2497 "VBNET.ATG" name = t.val; break; } case 63: { lexer.NextToken(); -#line 2497 "VBNET.ATG" +#line 2498 "VBNET.ATG" name = t.val; break; } case 64: { lexer.NextToken(); -#line 2498 "VBNET.ATG" +#line 2499 "VBNET.ATG" name = t.val; break; } case 65: { lexer.NextToken(); -#line 2499 "VBNET.ATG" +#line 2500 "VBNET.ATG" name = t.val; break; } case 66: { lexer.NextToken(); -#line 2500 "VBNET.ATG" +#line 2501 "VBNET.ATG" name = t.val; break; } case 67: { lexer.NextToken(); -#line 2501 "VBNET.ATG" +#line 2502 "VBNET.ATG" name = t.val; break; } case 68: { lexer.NextToken(); -#line 2502 "VBNET.ATG" +#line 2503 "VBNET.ATG" name = t.val; break; } case 70: { lexer.NextToken(); -#line 2503 "VBNET.ATG" +#line 2504 "VBNET.ATG" name = t.val; break; } case 71: { lexer.NextToken(); -#line 2504 "VBNET.ATG" +#line 2505 "VBNET.ATG" name = t.val; break; } case 72: { lexer.NextToken(); -#line 2505 "VBNET.ATG" +#line 2506 "VBNET.ATG" name = t.val; break; } case 73: { lexer.NextToken(); -#line 2506 "VBNET.ATG" +#line 2507 "VBNET.ATG" name = t.val; break; } case 74: { lexer.NextToken(); -#line 2507 "VBNET.ATG" +#line 2508 "VBNET.ATG" name = t.val; break; } case 75: { lexer.NextToken(); -#line 2508 "VBNET.ATG" +#line 2509 "VBNET.ATG" name = t.val; break; } case 76: { lexer.NextToken(); -#line 2509 "VBNET.ATG" +#line 2510 "VBNET.ATG" name = t.val; break; } case 77: { lexer.NextToken(); -#line 2510 "VBNET.ATG" +#line 2511 "VBNET.ATG" name = t.val; break; } case 78: { lexer.NextToken(); -#line 2511 "VBNET.ATG" +#line 2512 "VBNET.ATG" name = t.val; break; } case 79: { lexer.NextToken(); -#line 2512 "VBNET.ATG" +#line 2513 "VBNET.ATG" name = t.val; break; } case 80: { lexer.NextToken(); -#line 2513 "VBNET.ATG" +#line 2514 "VBNET.ATG" name = t.val; break; } case 81: { lexer.NextToken(); -#line 2514 "VBNET.ATG" +#line 2515 "VBNET.ATG" name = t.val; break; } case 82: { lexer.NextToken(); -#line 2515 "VBNET.ATG" +#line 2516 "VBNET.ATG" name = t.val; break; } case 83: { lexer.NextToken(); -#line 2516 "VBNET.ATG" +#line 2517 "VBNET.ATG" name = t.val; break; } case 84: { lexer.NextToken(); -#line 2517 "VBNET.ATG" +#line 2518 "VBNET.ATG" name = t.val; break; } case 85: { lexer.NextToken(); -#line 2518 "VBNET.ATG" +#line 2519 "VBNET.ATG" name = t.val; break; } case 86: { lexer.NextToken(); -#line 2519 "VBNET.ATG" +#line 2520 "VBNET.ATG" name = t.val; break; } case 87: { lexer.NextToken(); -#line 2520 "VBNET.ATG" +#line 2521 "VBNET.ATG" name = t.val; break; } case 88: { lexer.NextToken(); -#line 2521 "VBNET.ATG" +#line 2522 "VBNET.ATG" name = t.val; break; } case 89: { lexer.NextToken(); -#line 2522 "VBNET.ATG" +#line 2523 "VBNET.ATG" name = t.val; break; } case 90: { lexer.NextToken(); -#line 2523 "VBNET.ATG" +#line 2524 "VBNET.ATG" name = t.val; break; } case 91: { lexer.NextToken(); -#line 2524 "VBNET.ATG" +#line 2525 "VBNET.ATG" name = t.val; break; } case 92: { lexer.NextToken(); -#line 2525 "VBNET.ATG" +#line 2526 "VBNET.ATG" name = t.val; break; } case 93: { lexer.NextToken(); -#line 2526 "VBNET.ATG" +#line 2527 "VBNET.ATG" name = t.val; break; } case 94: { lexer.NextToken(); -#line 2527 "VBNET.ATG" +#line 2528 "VBNET.ATG" name = t.val; break; } case 95: { lexer.NextToken(); -#line 2528 "VBNET.ATG" +#line 2529 "VBNET.ATG" name = t.val; break; } case 96: { lexer.NextToken(); -#line 2529 "VBNET.ATG" +#line 2530 "VBNET.ATG" name = t.val; break; } case 97: { lexer.NextToken(); -#line 2530 "VBNET.ATG" +#line 2531 "VBNET.ATG" name = t.val; break; } case 98: { lexer.NextToken(); -#line 2531 "VBNET.ATG" +#line 2532 "VBNET.ATG" name = t.val; break; } case 99: { lexer.NextToken(); -#line 2532 "VBNET.ATG" +#line 2533 "VBNET.ATG" name = t.val; break; } case 100: { lexer.NextToken(); -#line 2533 "VBNET.ATG" +#line 2534 "VBNET.ATG" name = t.val; break; } case 101: { lexer.NextToken(); -#line 2534 "VBNET.ATG" +#line 2535 "VBNET.ATG" name = t.val; break; } case 102: { lexer.NextToken(); -#line 2535 "VBNET.ATG" +#line 2536 "VBNET.ATG" name = t.val; break; } case 103: { lexer.NextToken(); -#line 2536 "VBNET.ATG" +#line 2537 "VBNET.ATG" name = t.val; break; } case 104: { lexer.NextToken(); -#line 2537 "VBNET.ATG" +#line 2538 "VBNET.ATG" name = t.val; break; } case 105: { lexer.NextToken(); -#line 2538 "VBNET.ATG" +#line 2539 "VBNET.ATG" name = t.val; break; } case 106: { lexer.NextToken(); -#line 2539 "VBNET.ATG" +#line 2540 "VBNET.ATG" name = t.val; break; } case 107: { lexer.NextToken(); -#line 2540 "VBNET.ATG" +#line 2541 "VBNET.ATG" name = t.val; break; } case 108: { lexer.NextToken(); -#line 2541 "VBNET.ATG" +#line 2542 "VBNET.ATG" name = t.val; break; } case 109: { lexer.NextToken(); -#line 2542 "VBNET.ATG" +#line 2543 "VBNET.ATG" name = t.val; break; } case 110: { lexer.NextToken(); -#line 2543 "VBNET.ATG" +#line 2544 "VBNET.ATG" name = t.val; break; } case 111: { lexer.NextToken(); -#line 2544 "VBNET.ATG" +#line 2545 "VBNET.ATG" name = t.val; break; } case 112: { lexer.NextToken(); -#line 2545 "VBNET.ATG" +#line 2546 "VBNET.ATG" name = t.val; break; } case 113: { lexer.NextToken(); -#line 2546 "VBNET.ATG" +#line 2547 "VBNET.ATG" name = t.val; break; } case 114: { lexer.NextToken(); -#line 2547 "VBNET.ATG" +#line 2548 "VBNET.ATG" name = t.val; break; } case 115: { lexer.NextToken(); -#line 2548 "VBNET.ATG" +#line 2549 "VBNET.ATG" name = t.val; break; } case 116: { lexer.NextToken(); -#line 2549 "VBNET.ATG" +#line 2550 "VBNET.ATG" name = t.val; break; } case 117: { lexer.NextToken(); -#line 2550 "VBNET.ATG" +#line 2551 "VBNET.ATG" name = t.val; break; } case 118: { lexer.NextToken(); -#line 2551 "VBNET.ATG" +#line 2552 "VBNET.ATG" name = t.val; break; } case 119: { lexer.NextToken(); -#line 2552 "VBNET.ATG" +#line 2553 "VBNET.ATG" name = t.val; break; } case 120: { lexer.NextToken(); -#line 2553 "VBNET.ATG" +#line 2554 "VBNET.ATG" name = t.val; break; } case 121: { lexer.NextToken(); -#line 2554 "VBNET.ATG" +#line 2555 "VBNET.ATG" name = t.val; break; } case 122: { lexer.NextToken(); -#line 2555 "VBNET.ATG" +#line 2556 "VBNET.ATG" name = t.val; break; } case 123: { lexer.NextToken(); -#line 2556 "VBNET.ATG" +#line 2557 "VBNET.ATG" name = t.val; break; } case 124: { lexer.NextToken(); -#line 2557 "VBNET.ATG" +#line 2558 "VBNET.ATG" name = t.val; break; } case 125: { lexer.NextToken(); -#line 2558 "VBNET.ATG" +#line 2559 "VBNET.ATG" name = t.val; break; } case 126: { lexer.NextToken(); -#line 2559 "VBNET.ATG" +#line 2560 "VBNET.ATG" name = t.val; break; } case 127: { lexer.NextToken(); -#line 2560 "VBNET.ATG" +#line 2561 "VBNET.ATG" name = t.val; break; } case 128: { lexer.NextToken(); -#line 2561 "VBNET.ATG" +#line 2562 "VBNET.ATG" name = t.val; break; } case 129: { lexer.NextToken(); -#line 2562 "VBNET.ATG" +#line 2563 "VBNET.ATG" name = t.val; break; } case 130: { lexer.NextToken(); -#line 2563 "VBNET.ATG" +#line 2564 "VBNET.ATG" name = t.val; break; } case 131: { lexer.NextToken(); -#line 2564 "VBNET.ATG" +#line 2565 "VBNET.ATG" name = t.val; break; } case 132: { lexer.NextToken(); -#line 2565 "VBNET.ATG" +#line 2566 "VBNET.ATG" name = t.val; break; } case 134: { lexer.NextToken(); -#line 2566 "VBNET.ATG" +#line 2567 "VBNET.ATG" name = t.val; break; } case 135: { lexer.NextToken(); -#line 2567 "VBNET.ATG" +#line 2568 "VBNET.ATG" name = t.val; break; } case 136: { lexer.NextToken(); -#line 2568 "VBNET.ATG" +#line 2569 "VBNET.ATG" name = t.val; break; } case 137: { lexer.NextToken(); -#line 2569 "VBNET.ATG" +#line 2570 "VBNET.ATG" name = t.val; break; } case 138: { lexer.NextToken(); -#line 2570 "VBNET.ATG" +#line 2571 "VBNET.ATG" name = t.val; break; } case 139: { lexer.NextToken(); -#line 2571 "VBNET.ATG" +#line 2572 "VBNET.ATG" name = t.val; break; } case 140: { lexer.NextToken(); -#line 2572 "VBNET.ATG" +#line 2573 "VBNET.ATG" name = t.val; break; } case 142: { lexer.NextToken(); -#line 2573 "VBNET.ATG" +#line 2574 "VBNET.ATG" name = t.val; break; } case 143: { lexer.NextToken(); -#line 2574 "VBNET.ATG" +#line 2575 "VBNET.ATG" name = t.val; break; } case 144: { lexer.NextToken(); -#line 2575 "VBNET.ATG" +#line 2576 "VBNET.ATG" name = t.val; break; } case 145: { lexer.NextToken(); -#line 2576 "VBNET.ATG" +#line 2577 "VBNET.ATG" name = t.val; break; } case 146: { lexer.NextToken(); -#line 2577 "VBNET.ATG" +#line 2578 "VBNET.ATG" name = t.val; break; } case 147: { lexer.NextToken(); -#line 2578 "VBNET.ATG" +#line 2579 "VBNET.ATG" name = t.val; break; } case 148: { lexer.NextToken(); -#line 2579 "VBNET.ATG" +#line 2580 "VBNET.ATG" name = t.val; break; } case 149: { lexer.NextToken(); -#line 2580 "VBNET.ATG" +#line 2581 "VBNET.ATG" name = t.val; break; } case 150: { lexer.NextToken(); -#line 2581 "VBNET.ATG" +#line 2582 "VBNET.ATG" name = t.val; break; } case 151: { lexer.NextToken(); -#line 2582 "VBNET.ATG" +#line 2583 "VBNET.ATG" name = t.val; break; } case 152: { lexer.NextToken(); -#line 2583 "VBNET.ATG" +#line 2584 "VBNET.ATG" name = t.val; break; } case 153: { lexer.NextToken(); -#line 2584 "VBNET.ATG" +#line 2585 "VBNET.ATG" name = t.val; break; } case 154: { lexer.NextToken(); -#line 2585 "VBNET.ATG" +#line 2586 "VBNET.ATG" name = t.val; break; } case 155: { lexer.NextToken(); -#line 2586 "VBNET.ATG" +#line 2587 "VBNET.ATG" name = t.val; break; } case 156: { lexer.NextToken(); -#line 2587 "VBNET.ATG" +#line 2588 "VBNET.ATG" name = t.val; break; } case 157: { lexer.NextToken(); -#line 2588 "VBNET.ATG" +#line 2589 "VBNET.ATG" name = t.val; break; } case 158: { lexer.NextToken(); -#line 2589 "VBNET.ATG" +#line 2590 "VBNET.ATG" name = t.val; break; } case 159: { lexer.NextToken(); -#line 2590 "VBNET.ATG" +#line 2591 "VBNET.ATG" name = t.val; break; } case 160: { lexer.NextToken(); -#line 2591 "VBNET.ATG" +#line 2592 "VBNET.ATG" name = t.val; break; } case 161: { lexer.NextToken(); -#line 2592 "VBNET.ATG" +#line 2593 "VBNET.ATG" name = t.val; break; } case 162: { lexer.NextToken(); -#line 2593 "VBNET.ATG" +#line 2594 "VBNET.ATG" name = t.val; break; } case 163: { lexer.NextToken(); -#line 2594 "VBNET.ATG" +#line 2595 "VBNET.ATG" name = t.val; break; } case 165: { lexer.NextToken(); -#line 2595 "VBNET.ATG" +#line 2596 "VBNET.ATG" name = t.val; break; } case 166: { lexer.NextToken(); -#line 2596 "VBNET.ATG" +#line 2597 "VBNET.ATG" name = t.val; break; } case 167: { lexer.NextToken(); -#line 2597 "VBNET.ATG" +#line 2598 "VBNET.ATG" name = t.val; break; } case 168: { lexer.NextToken(); -#line 2598 "VBNET.ATG" +#line 2599 "VBNET.ATG" name = t.val; break; } case 170: { lexer.NextToken(); -#line 2599 "VBNET.ATG" +#line 2600 "VBNET.ATG" name = t.val; break; } case 171: { lexer.NextToken(); -#line 2600 "VBNET.ATG" +#line 2601 "VBNET.ATG" name = t.val; break; } case 172: { lexer.NextToken(); -#line 2601 "VBNET.ATG" +#line 2602 "VBNET.ATG" name = t.val; break; } case 173: { lexer.NextToken(); -#line 2602 "VBNET.ATG" +#line 2603 "VBNET.ATG" name = t.val; break; } case 174: { lexer.NextToken(); -#line 2603 "VBNET.ATG" +#line 2604 "VBNET.ATG" name = t.val; break; } case 175: { lexer.NextToken(); -#line 2604 "VBNET.ATG" +#line 2605 "VBNET.ATG" name = t.val; break; } case 176: { lexer.NextToken(); -#line 2605 "VBNET.ATG" +#line 2606 "VBNET.ATG" name = t.val; break; } case 177: { lexer.NextToken(); -#line 2606 "VBNET.ATG" +#line 2607 "VBNET.ATG" name = t.val; break; } case 178: { lexer.NextToken(); -#line 2607 "VBNET.ATG" +#line 2608 "VBNET.ATG" name = t.val; break; } case 179: { lexer.NextToken(); -#line 2608 "VBNET.ATG" +#line 2609 "VBNET.ATG" name = t.val; break; } case 180: { lexer.NextToken(); -#line 2609 "VBNET.ATG" +#line 2610 "VBNET.ATG" name = t.val; break; } case 181: { lexer.NextToken(); -#line 2610 "VBNET.ATG" +#line 2611 "VBNET.ATG" name = t.val; break; } case 182: { lexer.NextToken(); -#line 2611 "VBNET.ATG" +#line 2612 "VBNET.ATG" name = t.val; break; } case 183: { lexer.NextToken(); -#line 2612 "VBNET.ATG" +#line 2613 "VBNET.ATG" name = t.val; break; } case 184: { lexer.NextToken(); -#line 2613 "VBNET.ATG" +#line 2614 "VBNET.ATG" name = t.val; break; } case 185: { lexer.NextToken(); -#line 2614 "VBNET.ATG" +#line 2615 "VBNET.ATG" name = t.val; break; } case 186: { lexer.NextToken(); -#line 2615 "VBNET.ATG" +#line 2616 "VBNET.ATG" name = t.val; break; } case 187: { lexer.NextToken(); -#line 2616 "VBNET.ATG" +#line 2617 "VBNET.ATG" name = t.val; break; } case 188: { lexer.NextToken(); -#line 2617 "VBNET.ATG" +#line 2618 "VBNET.ATG" name = t.val; break; } case 189: { lexer.NextToken(); -#line 2618 "VBNET.ATG" +#line 2619 "VBNET.ATG" name = t.val; break; } case 190: { lexer.NextToken(); -#line 2619 "VBNET.ATG" +#line 2620 "VBNET.ATG" name = t.val; break; } case 191: { lexer.NextToken(); -#line 2620 "VBNET.ATG" +#line 2621 "VBNET.ATG" name = t.val; break; } case 192: { lexer.NextToken(); -#line 2621 "VBNET.ATG" +#line 2622 "VBNET.ATG" name = t.val; break; } case 193: { lexer.NextToken(); -#line 2622 "VBNET.ATG" +#line 2623 "VBNET.ATG" name = t.val; break; } case 194: { lexer.NextToken(); -#line 2623 "VBNET.ATG" +#line 2624 "VBNET.ATG" name = t.val; break; } case 195: { lexer.NextToken(); -#line 2624 "VBNET.ATG" +#line 2625 "VBNET.ATG" name = t.val; break; } case 196: { lexer.NextToken(); -#line 2625 "VBNET.ATG" +#line 2626 "VBNET.ATG" name = t.val; break; } case 197: { lexer.NextToken(); -#line 2626 "VBNET.ATG" +#line 2627 "VBNET.ATG" name = t.val; break; } @@ -4289,94 +4290,94 @@ out string name) { } void CastTarget( -#line 1466 "VBNET.ATG" +#line 1467 "VBNET.ATG" out TypeReference type) { -#line 1468 "VBNET.ATG" +#line 1469 "VBNET.ATG" type = null; switch (la.kind) { case 58: { lexer.NextToken(); -#line 1470 "VBNET.ATG" +#line 1471 "VBNET.ATG" type = new TypeReference("System.Boolean"); break; } case 59: { lexer.NextToken(); -#line 1471 "VBNET.ATG" +#line 1472 "VBNET.ATG" type = new TypeReference("System.Byte"); break; } case 60: { lexer.NextToken(); -#line 1472 "VBNET.ATG" +#line 1473 "VBNET.ATG" type = new TypeReference("System.Char"); break; } case 61: { lexer.NextToken(); -#line 1473 "VBNET.ATG" +#line 1474 "VBNET.ATG" type = new TypeReference("System.DateTime"); break; } case 63: { lexer.NextToken(); -#line 1474 "VBNET.ATG" +#line 1475 "VBNET.ATG" type = new TypeReference("System.Decimal"); break; } case 62: { lexer.NextToken(); -#line 1475 "VBNET.ATG" +#line 1476 "VBNET.ATG" type = new TypeReference("System.Double"); break; } case 65: { lexer.NextToken(); -#line 1476 "VBNET.ATG" +#line 1477 "VBNET.ATG" type = new TypeReference("System.Int32"); break; } case 67: { lexer.NextToken(); -#line 1477 "VBNET.ATG" +#line 1478 "VBNET.ATG" type = new TypeReference("System.Int64"); break; } case 68: { lexer.NextToken(); -#line 1478 "VBNET.ATG" +#line 1479 "VBNET.ATG" type = new TypeReference("System.Object"); break; } case 71: { lexer.NextToken(); -#line 1479 "VBNET.ATG" +#line 1480 "VBNET.ATG" type = new TypeReference("System.Int16"); break; } case 72: { lexer.NextToken(); -#line 1480 "VBNET.ATG" +#line 1481 "VBNET.ATG" type = new TypeReference("System.Single"); break; } case 73: { lexer.NextToken(); -#line 1481 "VBNET.ATG" +#line 1482 "VBNET.ATG" type = new TypeReference("System.String"); break; } @@ -4385,448 +4386,448 @@ out TypeReference type) { } void Argument( -#line 1641 "VBNET.ATG" +#line 1642 "VBNET.ATG" out Expression argumentexpr) { -#line 1643 "VBNET.ATG" +#line 1644 "VBNET.ATG" Expression expr; argumentexpr = null; string name; if ( -#line 1647 "VBNET.ATG" +#line 1648 "VBNET.ATG" IsNamedAssign()) { Identifier(); -#line 1647 "VBNET.ATG" +#line 1648 "VBNET.ATG" name = t.val; Expect(13); Expect(11); Expr( -#line 1647 "VBNET.ATG" +#line 1648 "VBNET.ATG" out expr); -#line 1649 "VBNET.ATG" +#line 1650 "VBNET.ATG" argumentexpr = new NamedArgumentExpression(name, expr); } else if (StartOf(17)) { Expr( -#line 1652 "VBNET.ATG" +#line 1653 "VBNET.ATG" out argumentexpr); } else SynErr(233); } void ConditionalAndExpr( -#line 1489 "VBNET.ATG" +#line 1490 "VBNET.ATG" out Expression outExpr) { -#line 1490 "VBNET.ATG" +#line 1491 "VBNET.ATG" Expression expr; InclusiveOrExpr( -#line 1491 "VBNET.ATG" +#line 1492 "VBNET.ATG" out outExpr); while (la.kind == 45) { lexer.NextToken(); InclusiveOrExpr( -#line 1491 "VBNET.ATG" +#line 1492 "VBNET.ATG" out expr); -#line 1491 "VBNET.ATG" +#line 1492 "VBNET.ATG" outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.LogicalAnd, expr); } } void InclusiveOrExpr( -#line 1494 "VBNET.ATG" +#line 1495 "VBNET.ATG" out Expression outExpr) { -#line 1495 "VBNET.ATG" +#line 1496 "VBNET.ATG" Expression expr; ExclusiveOrExpr( -#line 1496 "VBNET.ATG" +#line 1497 "VBNET.ATG" out outExpr); while (la.kind == 185) { lexer.NextToken(); ExclusiveOrExpr( -#line 1496 "VBNET.ATG" +#line 1497 "VBNET.ATG" out expr); -#line 1496 "VBNET.ATG" +#line 1497 "VBNET.ATG" outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.ExclusiveOr, expr); } } void ExclusiveOrExpr( -#line 1499 "VBNET.ATG" +#line 1500 "VBNET.ATG" out Expression outExpr) { -#line 1500 "VBNET.ATG" +#line 1501 "VBNET.ATG" Expression expr; AndExpr( -#line 1501 "VBNET.ATG" +#line 1502 "VBNET.ATG" out outExpr); while (la.kind == 137) { lexer.NextToken(); AndExpr( -#line 1501 "VBNET.ATG" +#line 1502 "VBNET.ATG" out expr); -#line 1501 "VBNET.ATG" +#line 1502 "VBNET.ATG" outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseOr, expr); } } void AndExpr( -#line 1504 "VBNET.ATG" +#line 1505 "VBNET.ATG" out Expression outExpr) { -#line 1505 "VBNET.ATG" +#line 1506 "VBNET.ATG" Expression expr; NotExpr( -#line 1506 "VBNET.ATG" +#line 1507 "VBNET.ATG" out outExpr); while (la.kind == 44) { lexer.NextToken(); NotExpr( -#line 1506 "VBNET.ATG" +#line 1507 "VBNET.ATG" out expr); -#line 1506 "VBNET.ATG" +#line 1507 "VBNET.ATG" outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseAnd, expr); } } void NotExpr( -#line 1509 "VBNET.ATG" +#line 1510 "VBNET.ATG" out Expression outExpr) { -#line 1510 "VBNET.ATG" +#line 1511 "VBNET.ATG" UnaryOperatorType uop = UnaryOperatorType.None; while (la.kind == 128) { lexer.NextToken(); -#line 1511 "VBNET.ATG" +#line 1512 "VBNET.ATG" uop = UnaryOperatorType.Not; } EqualityExpr( -#line 1512 "VBNET.ATG" +#line 1513 "VBNET.ATG" out outExpr); -#line 1513 "VBNET.ATG" +#line 1514 "VBNET.ATG" if (uop != UnaryOperatorType.None) outExpr = new UnaryOperatorExpression(outExpr, uop); } void EqualityExpr( -#line 1518 "VBNET.ATG" +#line 1519 "VBNET.ATG" out Expression outExpr) { -#line 1520 "VBNET.ATG" +#line 1521 "VBNET.ATG" Expression expr; BinaryOperatorType op = BinaryOperatorType.None; RelationalExpr( -#line 1523 "VBNET.ATG" +#line 1524 "VBNET.ATG" out outExpr); while (la.kind == 11 || la.kind == 27 || la.kind == 115) { if (la.kind == 27) { lexer.NextToken(); -#line 1526 "VBNET.ATG" +#line 1527 "VBNET.ATG" op = BinaryOperatorType.InEquality; } else if (la.kind == 11) { lexer.NextToken(); -#line 1527 "VBNET.ATG" +#line 1528 "VBNET.ATG" op = BinaryOperatorType.Equality; } else { lexer.NextToken(); -#line 1528 "VBNET.ATG" +#line 1529 "VBNET.ATG" op = BinaryOperatorType.Like; } RelationalExpr( -#line 1530 "VBNET.ATG" +#line 1531 "VBNET.ATG" out expr); -#line 1530 "VBNET.ATG" +#line 1531 "VBNET.ATG" outExpr = new BinaryOperatorExpression(outExpr, op, expr); } } void RelationalExpr( -#line 1534 "VBNET.ATG" +#line 1535 "VBNET.ATG" out Expression outExpr) { -#line 1536 "VBNET.ATG" +#line 1537 "VBNET.ATG" Expression expr; BinaryOperatorType op = BinaryOperatorType.None; ShiftExpr( -#line 1539 "VBNET.ATG" +#line 1540 "VBNET.ATG" out outExpr); while (StartOf(21)) { if (StartOf(22)) { if (la.kind == 26) { lexer.NextToken(); -#line 1542 "VBNET.ATG" +#line 1543 "VBNET.ATG" op = BinaryOperatorType.LessThan; } else if (la.kind == 25) { lexer.NextToken(); -#line 1543 "VBNET.ATG" +#line 1544 "VBNET.ATG" op = BinaryOperatorType.GreaterThan; } else if (la.kind == 29) { lexer.NextToken(); -#line 1544 "VBNET.ATG" +#line 1545 "VBNET.ATG" op = BinaryOperatorType.LessThanOrEqual; } else if (la.kind == 28) { lexer.NextToken(); -#line 1545 "VBNET.ATG" +#line 1546 "VBNET.ATG" op = BinaryOperatorType.GreaterThanOrEqual; } else SynErr(234); ShiftExpr( -#line 1547 "VBNET.ATG" +#line 1548 "VBNET.ATG" out expr); -#line 1547 "VBNET.ATG" +#line 1548 "VBNET.ATG" outExpr = new BinaryOperatorExpression(outExpr, op, expr); } else { if (la.kind == 112) { lexer.NextToken(); -#line 1550 "VBNET.ATG" - op = BinaryOperatorType.IS; +#line 1551 "VBNET.ATG" + op = BinaryOperatorType.ReferenceEquality; } else if (la.kind == 189) { lexer.NextToken(); -#line 1551 "VBNET.ATG" - op = BinaryOperatorType.IsNot; +#line 1552 "VBNET.ATG" + op = BinaryOperatorType.ReferenceInequality; } else SynErr(235); Expr( -#line 1552 "VBNET.ATG" +#line 1553 "VBNET.ATG" out expr); -#line 1552 "VBNET.ATG" +#line 1553 "VBNET.ATG" outExpr = new BinaryOperatorExpression(outExpr, op, expr); } } } void ShiftExpr( -#line 1556 "VBNET.ATG" +#line 1557 "VBNET.ATG" out Expression outExpr) { -#line 1558 "VBNET.ATG" +#line 1559 "VBNET.ATG" Expression expr; BinaryOperatorType op = BinaryOperatorType.None; AdditiveExpr( -#line 1561 "VBNET.ATG" +#line 1562 "VBNET.ATG" out outExpr); while (la.kind == 30 || la.kind == 31) { if (la.kind == 30) { lexer.NextToken(); -#line 1564 "VBNET.ATG" +#line 1565 "VBNET.ATG" op = BinaryOperatorType.ShiftLeft; } else { lexer.NextToken(); -#line 1565 "VBNET.ATG" +#line 1566 "VBNET.ATG" op = BinaryOperatorType.ShiftRight; } AdditiveExpr( -#line 1567 "VBNET.ATG" +#line 1568 "VBNET.ATG" out expr); -#line 1567 "VBNET.ATG" +#line 1568 "VBNET.ATG" outExpr = new BinaryOperatorExpression(outExpr, op, expr); } } void AdditiveExpr( -#line 1571 "VBNET.ATG" +#line 1572 "VBNET.ATG" out Expression outExpr) { -#line 1573 "VBNET.ATG" +#line 1574 "VBNET.ATG" Expression expr; BinaryOperatorType op = BinaryOperatorType.None; MultiplicativeExpr( -#line 1576 "VBNET.ATG" +#line 1577 "VBNET.ATG" out outExpr); while (la.kind == 14 || la.kind == 15 || la.kind == 19) { if (la.kind == 14) { lexer.NextToken(); -#line 1579 "VBNET.ATG" +#line 1580 "VBNET.ATG" op = BinaryOperatorType.Add; } else if (la.kind == 15) { lexer.NextToken(); -#line 1580 "VBNET.ATG" +#line 1581 "VBNET.ATG" op = BinaryOperatorType.Subtract; } else { lexer.NextToken(); -#line 1581 "VBNET.ATG" +#line 1582 "VBNET.ATG" op = BinaryOperatorType.Concat; } MultiplicativeExpr( -#line 1583 "VBNET.ATG" +#line 1584 "VBNET.ATG" out expr); -#line 1583 "VBNET.ATG" +#line 1584 "VBNET.ATG" outExpr = new BinaryOperatorExpression(outExpr, op, expr); } } void MultiplicativeExpr( -#line 1587 "VBNET.ATG" +#line 1588 "VBNET.ATG" out Expression outExpr) { -#line 1589 "VBNET.ATG" +#line 1590 "VBNET.ATG" Expression expr; BinaryOperatorType op = BinaryOperatorType.None; UnaryExpr( -#line 1592 "VBNET.ATG" +#line 1593 "VBNET.ATG" out outExpr); while (StartOf(23)) { if (la.kind == 16) { lexer.NextToken(); -#line 1595 "VBNET.ATG" +#line 1596 "VBNET.ATG" op = BinaryOperatorType.Multiply; } else if (la.kind == 17) { lexer.NextToken(); -#line 1596 "VBNET.ATG" +#line 1597 "VBNET.ATG" op = BinaryOperatorType.Divide; } else if (la.kind == 18) { lexer.NextToken(); -#line 1597 "VBNET.ATG" +#line 1598 "VBNET.ATG" op = BinaryOperatorType.DivideInteger; } else if (la.kind == 119) { lexer.NextToken(); -#line 1598 "VBNET.ATG" +#line 1599 "VBNET.ATG" op = BinaryOperatorType.Modulus; } else { lexer.NextToken(); -#line 1599 "VBNET.ATG" +#line 1600 "VBNET.ATG" op = BinaryOperatorType.Power; } UnaryExpr( -#line 1601 "VBNET.ATG" +#line 1602 "VBNET.ATG" out expr); -#line 1601 "VBNET.ATG" +#line 1602 "VBNET.ATG" outExpr = new BinaryOperatorExpression(outExpr, op, expr); } } void TypeNameWithoutRank( -#line 1656 "VBNET.ATG" +#line 1657 "VBNET.ATG" out TypeReference typeref) { NonArrayTypeName( -#line 1658 "VBNET.ATG" +#line 1659 "VBNET.ATG" out typeref); -#line 1660 "VBNET.ATG" +#line 1661 "VBNET.ATG" typeref = new TypeReference(typeref == null ? "UNKNOWN" : typeref.Type, new int[] {} ); } void ArgumentList( -#line 1626 "VBNET.ATG" +#line 1627 "VBNET.ATG" out ArrayList arguments) { -#line 1628 "VBNET.ATG" +#line 1629 "VBNET.ATG" arguments = new ArrayList(); Expression expr = null; if (StartOf(17)) { Argument( -#line 1632 "VBNET.ATG" +#line 1633 "VBNET.ATG" out expr); -#line 1632 "VBNET.ATG" +#line 1633 "VBNET.ATG" if (expr != null) { arguments.Add(expr); } while (la.kind == 12) { lexer.NextToken(); Argument( -#line 1635 "VBNET.ATG" +#line 1636 "VBNET.ATG" out expr); -#line 1635 "VBNET.ATG" +#line 1636 "VBNET.ATG" if (expr != null) { arguments.Add(expr); } } } } void NonArrayTypeName( -#line 1678 "VBNET.ATG" +#line 1679 "VBNET.ATG" out TypeReference typeref) { -#line 1680 "VBNET.ATG" +#line 1681 "VBNET.ATG" string name; typeref = null; if (StartOf(9)) { Qualident( -#line 1683 "VBNET.ATG" +#line 1684 "VBNET.ATG" out name); -#line 1683 "VBNET.ATG" +#line 1684 "VBNET.ATG" typeref = new TypeReference(name); } else if (la.kind == 132) { lexer.NextToken(); -#line 1684 "VBNET.ATG" +#line 1685 "VBNET.ATG" typeref = new TypeReference("System.Object"); } else if (StartOf(24)) { PrimitiveTypeName( -#line 1685 "VBNET.ATG" +#line 1686 "VBNET.ATG" out name); -#line 1685 "VBNET.ATG" +#line 1686 "VBNET.ATG" typeref = new TypeReference(name); } else SynErr(236); } void ArrayTypeModifiers( -#line 1698 "VBNET.ATG" +#line 1699 "VBNET.ATG" out ArrayList arrayModifiers) { -#line 1700 "VBNET.ATG" +#line 1701 "VBNET.ATG" arrayModifiers = new ArrayList(); int i = 0; while ( -#line 1703 "VBNET.ATG" +#line 1704 "VBNET.ATG" IsDims()) { Expect(23); if (la.kind == 12 || la.kind == 24) { RankList( -#line 1705 "VBNET.ATG" +#line 1706 "VBNET.ATG" out i); } -#line 1707 "VBNET.ATG" +#line 1708 "VBNET.ATG" arrayModifiers.Add(i); Expect(24); } -#line 1712 "VBNET.ATG" +#line 1713 "VBNET.ATG" if(arrayModifiers.Count == 0) { arrayModifiers = null; } @@ -4834,65 +4835,65 @@ out i); } void RankList( -#line 1719 "VBNET.ATG" +#line 1720 "VBNET.ATG" out int i) { -#line 1720 "VBNET.ATG" +#line 1721 "VBNET.ATG" i = 0; while (la.kind == 12) { lexer.NextToken(); -#line 1721 "VBNET.ATG" +#line 1722 "VBNET.ATG" ++i; } } void Attribute( -#line 1745 "VBNET.ATG" +#line 1746 "VBNET.ATG" out ICSharpCode.NRefactory.Parser.AST.Attribute attribute) { -#line 1746 "VBNET.ATG" +#line 1747 "VBNET.ATG" string qualident; Qualident( -#line 1747 "VBNET.ATG" +#line 1748 "VBNET.ATG" out qualident); -#line 1748 "VBNET.ATG" +#line 1749 "VBNET.ATG" ArrayList positional = new ArrayList();ArrayList named = new ArrayList(); string name = qualident; if (la.kind == 23) { AttributeArguments( -#line 1751 "VBNET.ATG" +#line 1752 "VBNET.ATG" ref positional, ref named); } -#line 1753 "VBNET.ATG" +#line 1754 "VBNET.ATG" attribute = new ICSharpCode.NRefactory.Parser.AST.Attribute(name, positional, named); } void AttributeArguments( -#line 1758 "VBNET.ATG" +#line 1759 "VBNET.ATG" ref ArrayList positional, ref ArrayList named) { -#line 1760 "VBNET.ATG" +#line 1761 "VBNET.ATG" bool nameFound = false; string name = ""; Expression expr; Expect(23); if ( -#line 1766 "VBNET.ATG" +#line 1767 "VBNET.ATG" IsNotClosingParenthesis()) { if ( -#line 1768 "VBNET.ATG" +#line 1769 "VBNET.ATG" IsNamedAssign()) { -#line 1768 "VBNET.ATG" +#line 1769 "VBNET.ATG" nameFound = true; IdentifierOrKeyword( -#line 1769 "VBNET.ATG" +#line 1770 "VBNET.ATG" out name); if (la.kind == 13) { lexer.NextToken(); @@ -4900,10 +4901,10 @@ out name); Expect(11); } Expr( -#line 1771 "VBNET.ATG" +#line 1772 "VBNET.ATG" out expr); -#line 1773 "VBNET.ATG" +#line 1774 "VBNET.ATG" if (expr != null) { if(name == "") positional.Add(expr); else { named.Add(new NamedArgumentExpression(name, expr)); name = ""; } } @@ -4911,13 +4912,13 @@ out expr); while (la.kind == 12) { lexer.NextToken(); if ( -#line 1780 "VBNET.ATG" +#line 1781 "VBNET.ATG" IsNamedAssign()) { -#line 1780 "VBNET.ATG" +#line 1781 "VBNET.ATG" nameFound = true; IdentifierOrKeyword( -#line 1781 "VBNET.ATG" +#line 1782 "VBNET.ATG" out name); if (la.kind == 13) { lexer.NextToken(); @@ -4925,14 +4926,14 @@ out name); Expect(11); } else if (StartOf(17)) { -#line 1783 "VBNET.ATG" +#line 1784 "VBNET.ATG" if (nameFound) Error("no positional argument after named argument"); } else SynErr(237); Expr( -#line 1784 "VBNET.ATG" +#line 1785 "VBNET.ATG" out expr); -#line 1784 "VBNET.ATG" +#line 1785 "VBNET.ATG" if (expr != null) { if(name == "") positional.Add(expr); else { named.Add(new NamedArgumentExpression(name, expr)); name = ""; } } @@ -4943,10 +4944,10 @@ out expr); } void FormalParameter( -#line 1853 "VBNET.ATG" +#line 1854 "VBNET.ATG" out ParameterDeclarationExpression p) { -#line 1855 "VBNET.ATG" +#line 1856 "VBNET.ATG" TypeReference type = null; ParamModifiers mod = new ParamModifiers(this); Expression expr = null; @@ -4954,28 +4955,28 @@ out ParameterDeclarationExpression p) { while (StartOf(25)) { ParameterModifier( -#line 1860 "VBNET.ATG" +#line 1861 "VBNET.ATG" mod); } Identifier(); -#line 1861 "VBNET.ATG" +#line 1862 "VBNET.ATG" string parameterName = t.val; if ( -#line 1862 "VBNET.ATG" +#line 1863 "VBNET.ATG" IsDims()) { ArrayTypeModifiers( -#line 1862 "VBNET.ATG" +#line 1863 "VBNET.ATG" out arrayModifiers); } if (la.kind == 47) { lexer.NextToken(); TypeName( -#line 1863 "VBNET.ATG" +#line 1864 "VBNET.ATG" out type); } -#line 1865 "VBNET.ATG" +#line 1866 "VBNET.ATG" if(type != null) { if (arrayModifiers != null) { if (type.RankSpecifier != null) { @@ -4991,45 +4992,45 @@ out type); if (la.kind == 11) { lexer.NextToken(); Expr( -#line 1877 "VBNET.ATG" +#line 1878 "VBNET.ATG" out expr); } -#line 1879 "VBNET.ATG" +#line 1880 "VBNET.ATG" mod.Check(); p = new ParameterDeclarationExpression(type, parameterName, mod.Modifier, expr); } void ParameterModifier( -#line 2651 "VBNET.ATG" +#line 2652 "VBNET.ATG" ParamModifiers m) { if (la.kind == 54) { lexer.NextToken(); -#line 2652 "VBNET.ATG" +#line 2653 "VBNET.ATG" m.Add(ParamModifier.In); } else if (la.kind == 52) { lexer.NextToken(); -#line 2653 "VBNET.ATG" +#line 2654 "VBNET.ATG" m.Add(ParamModifier.Ref); } else if (la.kind == 136) { lexer.NextToken(); -#line 2654 "VBNET.ATG" +#line 2655 "VBNET.ATG" m.Add(ParamModifier.Optional); } else if (la.kind == 143) { lexer.NextToken(); -#line 2655 "VBNET.ATG" +#line 2656 "VBNET.ATG" m.Add(ParamModifier.Params); } else SynErr(238); } void Statement() { -#line 1907 "VBNET.ATG" +#line 1908 "VBNET.ATG" Statement stmt = null; Point startPos = la.Location; string label = String.Empty; @@ -5037,34 +5038,34 @@ ParamModifiers m) { if (la.kind == 1 || la.kind == 13) { } else if ( -#line 1913 "VBNET.ATG" +#line 1914 "VBNET.ATG" IsLabel()) { LabelName( -#line 1913 "VBNET.ATG" +#line 1914 "VBNET.ATG" out label); -#line 1915 "VBNET.ATG" +#line 1916 "VBNET.ATG" compilationUnit.AddChild(new LabelStatement(t.val)); Expect(13); Statement(); } else if (StartOf(26)) { EmbeddedStatement( -#line 1918 "VBNET.ATG" +#line 1919 "VBNET.ATG" out stmt); -#line 1918 "VBNET.ATG" +#line 1919 "VBNET.ATG" compilationUnit.AddChild(stmt); } else if (StartOf(27)) { LocalDeclarationStatement( -#line 1919 "VBNET.ATG" +#line 1920 "VBNET.ATG" out stmt); -#line 1919 "VBNET.ATG" +#line 1920 "VBNET.ATG" compilationUnit.AddChild(stmt); } else SynErr(239); -#line 1922 "VBNET.ATG" +#line 1923 "VBNET.ATG" if (stmt != null) { stmt.StartLocation = startPos; stmt.EndLocation = t.Location; @@ -5073,30 +5074,30 @@ out stmt); } void LabelName( -#line 2303 "VBNET.ATG" +#line 2304 "VBNET.ATG" out string name) { -#line 2305 "VBNET.ATG" +#line 2306 "VBNET.ATG" name = String.Empty; if (StartOf(9)) { Identifier(); -#line 2307 "VBNET.ATG" +#line 2308 "VBNET.ATG" name = t.val; } else if (la.kind == 5) { lexer.NextToken(); -#line 2308 "VBNET.ATG" +#line 2309 "VBNET.ATG" name = t.val; } else SynErr(240); } void EmbeddedStatement( -#line 1961 "VBNET.ATG" +#line 1962 "VBNET.ATG" out Statement statement) { -#line 1963 "VBNET.ATG" +#line 1964 "VBNET.ATG" Statement embeddedStatement = null; statement = null; Expression expr = null; @@ -5106,103 +5107,103 @@ out Statement statement) { case 93: { lexer.NextToken(); -#line 1968 "VBNET.ATG" +#line 1969 "VBNET.ATG" ExitType exitType = ExitType.None; switch (la.kind) { case 167: { lexer.NextToken(); -#line 1970 "VBNET.ATG" +#line 1971 "VBNET.ATG" exitType = ExitType.Sub; break; } case 99: { lexer.NextToken(); -#line 1972 "VBNET.ATG" +#line 1973 "VBNET.ATG" exitType = ExitType.Function; break; } case 146: { lexer.NextToken(); -#line 1974 "VBNET.ATG" +#line 1975 "VBNET.ATG" exitType = ExitType.Property; break; } case 82: { lexer.NextToken(); -#line 1976 "VBNET.ATG" +#line 1977 "VBNET.ATG" exitType = ExitType.Do; break; } case 97: { lexer.NextToken(); -#line 1978 "VBNET.ATG" +#line 1979 "VBNET.ATG" exitType = ExitType.For; break; } case 174: { lexer.NextToken(); -#line 1980 "VBNET.ATG" +#line 1981 "VBNET.ATG" exitType = ExitType.Try; break; } case 181: { lexer.NextToken(); -#line 1982 "VBNET.ATG" +#line 1983 "VBNET.ATG" exitType = ExitType.While; break; } case 155: { lexer.NextToken(); -#line 1984 "VBNET.ATG" +#line 1985 "VBNET.ATG" exitType = ExitType.Select; break; } default: SynErr(241); break; } -#line 1986 "VBNET.ATG" +#line 1987 "VBNET.ATG" statement = new ExitStatement(exitType); break; } case 174: { TryStatement( -#line 1987 "VBNET.ATG" +#line 1988 "VBNET.ATG" out statement); break; } case 186: { lexer.NextToken(); -#line 1988 "VBNET.ATG" +#line 1989 "VBNET.ATG" ContinueType continueType = ContinueType.None; if (la.kind == 82 || la.kind == 97 || la.kind == 181) { if (la.kind == 82) { lexer.NextToken(); -#line 1988 "VBNET.ATG" +#line 1989 "VBNET.ATG" continueType = ContinueType.Do; } else if (la.kind == 97) { lexer.NextToken(); -#line 1988 "VBNET.ATG" +#line 1989 "VBNET.ATG" continueType = ContinueType.For; } else { lexer.NextToken(); -#line 1988 "VBNET.ATG" +#line 1989 "VBNET.ATG" continueType = ContinueType.While; } } -#line 1988 "VBNET.ATG" +#line 1989 "VBNET.ATG" statement = new ContinueStatement(continueType); break; } @@ -5210,11 +5211,11 @@ out statement); lexer.NextToken(); if (StartOf(17)) { Expr( -#line 1990 "VBNET.ATG" +#line 1991 "VBNET.ATG" out expr); } -#line 1990 "VBNET.ATG" +#line 1991 "VBNET.ATG" statement = new ThrowStatement(expr); break; } @@ -5222,27 +5223,27 @@ out expr); lexer.NextToken(); if (StartOf(17)) { Expr( -#line 1992 "VBNET.ATG" +#line 1993 "VBNET.ATG" out expr); } -#line 1992 "VBNET.ATG" +#line 1993 "VBNET.ATG" statement = new ReturnStatement(expr); break; } case 168: { lexer.NextToken(); Expr( -#line 1994 "VBNET.ATG" +#line 1995 "VBNET.ATG" out expr); EndOfStmt(); Block( -#line 1994 "VBNET.ATG" +#line 1995 "VBNET.ATG" out embeddedStatement); Expect(87); Expect(168); -#line 1995 "VBNET.ATG" +#line 1996 "VBNET.ATG" statement = new LockStatement(expr, embeddedStatement); break; } @@ -5250,42 +5251,42 @@ out embeddedStatement); lexer.NextToken(); Identifier(); -#line 1997 "VBNET.ATG" +#line 1998 "VBNET.ATG" name = t.val; if (la.kind == 23) { lexer.NextToken(); if (StartOf(16)) { ArgumentList( -#line 1998 "VBNET.ATG" +#line 1999 "VBNET.ATG" out p); } Expect(24); } -#line 1999 "VBNET.ATG" +#line 2000 "VBNET.ATG" statement = new RaiseEventStatement(name, p); break; } case 182: { WithStatement( -#line 2001 "VBNET.ATG" +#line 2002 "VBNET.ATG" out statement); break; } case 41: { lexer.NextToken(); -#line 2003 "VBNET.ATG" +#line 2004 "VBNET.ATG" Expression handlerExpr = null; Expr( -#line 2004 "VBNET.ATG" +#line 2005 "VBNET.ATG" out expr); Expect(12); Expr( -#line 2004 "VBNET.ATG" +#line 2005 "VBNET.ATG" out handlerExpr); -#line 2006 "VBNET.ATG" +#line 2007 "VBNET.ATG" statement = new AddHandlerStatement(expr, handlerExpr); break; @@ -5293,17 +5294,17 @@ out handlerExpr); case 152: { lexer.NextToken(); -#line 2009 "VBNET.ATG" +#line 2010 "VBNET.ATG" Expression handlerExpr = null; Expr( -#line 2010 "VBNET.ATG" +#line 2011 "VBNET.ATG" out expr); Expect(12); Expr( -#line 2010 "VBNET.ATG" +#line 2011 "VBNET.ATG" out handlerExpr); -#line 2012 "VBNET.ATG" +#line 2013 "VBNET.ATG" statement = new RemoveHandlerStatement(expr, handlerExpr); break; @@ -5311,16 +5312,16 @@ out handlerExpr); case 181: { lexer.NextToken(); Expr( -#line 2015 "VBNET.ATG" +#line 2016 "VBNET.ATG" out expr); EndOfStmt(); Block( -#line 2016 "VBNET.ATG" +#line 2017 "VBNET.ATG" out embeddedStatement); Expect(87); Expect(181); -#line 2018 "VBNET.ATG" +#line 2019 "VBNET.ATG" statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.Start); break; @@ -5328,23 +5329,23 @@ out embeddedStatement); case 82: { lexer.NextToken(); -#line 2023 "VBNET.ATG" +#line 2024 "VBNET.ATG" ConditionType conditionType = ConditionType.None; if (la.kind == 177 || la.kind == 181) { WhileOrUntil( -#line 2026 "VBNET.ATG" +#line 2027 "VBNET.ATG" out conditionType); Expr( -#line 2026 "VBNET.ATG" +#line 2027 "VBNET.ATG" out expr); EndOfStmt(); Block( -#line 2027 "VBNET.ATG" +#line 2028 "VBNET.ATG" out embeddedStatement); Expect(117); -#line 2030 "VBNET.ATG" +#line 2031 "VBNET.ATG" statement = new DoLoopStatement(expr, embeddedStatement, conditionType == ConditionType.While ? ConditionType.DoWhile : conditionType, @@ -5353,19 +5354,19 @@ out embeddedStatement); } else if (la.kind == 1 || la.kind == 13) { EndOfStmt(); Block( -#line 2037 "VBNET.ATG" +#line 2038 "VBNET.ATG" out embeddedStatement); Expect(117); if (la.kind == 177 || la.kind == 181) { WhileOrUntil( -#line 2038 "VBNET.ATG" +#line 2039 "VBNET.ATG" out conditionType); Expr( -#line 2038 "VBNET.ATG" +#line 2039 "VBNET.ATG" out expr); } -#line 2040 "VBNET.ATG" +#line 2041 "VBNET.ATG" statement = new DoLoopStatement(expr, embeddedStatement, conditionType, ConditionPosition.End); } else SynErr(242); @@ -5374,7 +5375,7 @@ out expr); case 97: { lexer.NextToken(); -#line 2045 "VBNET.ATG" +#line 2046 "VBNET.ATG" Expression group = null; TypeReference typeReference; string typeName; @@ -5383,24 +5384,24 @@ out expr); if (la.kind == 84) { lexer.NextToken(); LoopControlVariable( -#line 2052 "VBNET.ATG" +#line 2053 "VBNET.ATG" out typeReference, out typeName); Expect(108); Expr( -#line 2053 "VBNET.ATG" +#line 2054 "VBNET.ATG" out group); EndOfStmt(); Block( -#line 2054 "VBNET.ATG" +#line 2055 "VBNET.ATG" out embeddedStatement); Expect(127); if (StartOf(17)) { Expr( -#line 2055 "VBNET.ATG" +#line 2056 "VBNET.ATG" out expr); } -#line 2057 "VBNET.ATG" +#line 2058 "VBNET.ATG" statement = new ForeachStatement(typeReference, typeName, group, @@ -5412,53 +5413,53 @@ out expr); } else if (StartOf(9)) { -#line 2068 "VBNET.ATG" +#line 2069 "VBNET.ATG" Expression start = null; Expression end = null; Expression step = null; Expression nextExpr = null;ArrayList nextExpressions = null; LoopControlVariable( -#line 2073 "VBNET.ATG" +#line 2074 "VBNET.ATG" out typeReference, out typeName); Expect(11); Expr( -#line 2074 "VBNET.ATG" +#line 2075 "VBNET.ATG" out start); Expect(172); Expr( -#line 2074 "VBNET.ATG" +#line 2075 "VBNET.ATG" out end); if (la.kind == 162) { lexer.NextToken(); Expr( -#line 2074 "VBNET.ATG" +#line 2075 "VBNET.ATG" out step); } EndOfStmt(); Block( -#line 2075 "VBNET.ATG" +#line 2076 "VBNET.ATG" out embeddedStatement); Expect(127); if (StartOf(17)) { Expr( -#line 2078 "VBNET.ATG" +#line 2079 "VBNET.ATG" out nextExpr); -#line 2078 "VBNET.ATG" +#line 2079 "VBNET.ATG" nextExpressions = new ArrayList(); nextExpressions.Add(nextExpr); while (la.kind == 12) { lexer.NextToken(); Expr( -#line 2079 "VBNET.ATG" +#line 2080 "VBNET.ATG" out nextExpr); -#line 2079 "VBNET.ATG" +#line 2080 "VBNET.ATG" nextExpressions.Add(nextExpr); } } -#line 2082 "VBNET.ATG" +#line 2083 "VBNET.ATG" statement = new ForNextStatement(typeReference, typeName, start, end, step, embeddedStatement, nextExpressions); } else SynErr(243); @@ -5467,29 +5468,29 @@ out nextExpr); case 91: { lexer.NextToken(); Expr( -#line 2086 "VBNET.ATG" +#line 2087 "VBNET.ATG" out expr); -#line 2086 "VBNET.ATG" +#line 2087 "VBNET.ATG" statement = new ErrorStatement(expr); break; } case 151: { lexer.NextToken(); -#line 2088 "VBNET.ATG" +#line 2089 "VBNET.ATG" Expression redimclause = null; bool isPreserve = false; if (la.kind == 144) { lexer.NextToken(); -#line 2088 "VBNET.ATG" +#line 2089 "VBNET.ATG" isPreserve = true; } Expr( -#line 2089 "VBNET.ATG" +#line 2090 "VBNET.ATG" out redimclause); -#line 2091 "VBNET.ATG" +#line 2092 "VBNET.ATG" ReDimStatement reDimStatement = new ReDimStatement(isPreserve); statement = reDimStatement; reDimStatement.ReDimClauses.Add(redimclause as InvocationExpression); @@ -5497,10 +5498,10 @@ out redimclause); while (la.kind == 12) { lexer.NextToken(); Expr( -#line 2095 "VBNET.ATG" +#line 2096 "VBNET.ATG" out redimclause); -#line 2095 "VBNET.ATG" +#line 2096 "VBNET.ATG" reDimStatement.ReDimClauses.Add(redimclause as InvocationExpression); } break; @@ -5508,10 +5509,10 @@ out redimclause); case 90: { lexer.NextToken(); Expr( -#line 2098 "VBNET.ATG" +#line 2099 "VBNET.ATG" out expr); -#line 2099 "VBNET.ATG" +#line 2100 "VBNET.ATG" ArrayList arrays = new ArrayList(); if (expr != null) { arrays.Add(expr);} EraseStatement eraseStatement = new EraseStatement(arrays); @@ -5520,53 +5521,53 @@ out expr); while (la.kind == 12) { lexer.NextToken(); Expr( -#line 2104 "VBNET.ATG" +#line 2105 "VBNET.ATG" out expr); -#line 2104 "VBNET.ATG" +#line 2105 "VBNET.ATG" if (expr != null) { arrays.Add(expr); } } -#line 2105 "VBNET.ATG" +#line 2106 "VBNET.ATG" statement = eraseStatement; break; } case 163: { lexer.NextToken(); -#line 2107 "VBNET.ATG" +#line 2108 "VBNET.ATG" statement = new StopStatement(); break; } case 105: { lexer.NextToken(); Expr( -#line 2109 "VBNET.ATG" +#line 2110 "VBNET.ATG" out expr); if (la.kind == 170) { lexer.NextToken(); } if ( -#line 2111 "VBNET.ATG" +#line 2112 "VBNET.ATG" IsEndStmtAhead()) { Expect(87); -#line 2111 "VBNET.ATG" +#line 2112 "VBNET.ATG" statement = new IfElseStatement(expr, new EndStatement()); } else if (la.kind == 1 || la.kind == 13) { EndOfStmt(); Block( -#line 2114 "VBNET.ATG" +#line 2115 "VBNET.ATG" out embeddedStatement); -#line 2116 "VBNET.ATG" +#line 2117 "VBNET.ATG" IfElseStatement ifStatement = new IfElseStatement(expr, embeddedStatement); while (la.kind == 86 || -#line 2120 "VBNET.ATG" +#line 2121 "VBNET.ATG" IsElseIf()) { if ( -#line 2120 "VBNET.ATG" +#line 2121 "VBNET.ATG" IsElseIf()) { Expect(85); Expect(105); @@ -5574,20 +5575,20 @@ IsElseIf()) { lexer.NextToken(); } -#line 2123 "VBNET.ATG" +#line 2124 "VBNET.ATG" Expression condition = null; Statement block = null; Expr( -#line 2124 "VBNET.ATG" +#line 2125 "VBNET.ATG" out condition); if (la.kind == 170) { lexer.NextToken(); } EndOfStmt(); Block( -#line 2125 "VBNET.ATG" +#line 2126 "VBNET.ATG" out block); -#line 2127 "VBNET.ATG" +#line 2128 "VBNET.ATG" ifStatement.ElseIfSections.Add(new ElseIfSection(condition, block)); } @@ -5595,59 +5596,59 @@ out block); lexer.NextToken(); EndOfStmt(); Block( -#line 2132 "VBNET.ATG" +#line 2133 "VBNET.ATG" out embeddedStatement); -#line 2134 "VBNET.ATG" +#line 2135 "VBNET.ATG" ifStatement.FalseStatement.Add(embeddedStatement); } Expect(87); Expect(105); -#line 2138 "VBNET.ATG" +#line 2139 "VBNET.ATG" statement = ifStatement; } else if (StartOf(26)) { EmbeddedStatement( -#line 2141 "VBNET.ATG" +#line 2142 "VBNET.ATG" out embeddedStatement); -#line 2143 "VBNET.ATG" +#line 2144 "VBNET.ATG" IfElseStatement ifStatement = new IfElseStatement(expr, embeddedStatement); while (la.kind == 13) { lexer.NextToken(); EmbeddedStatement( -#line 2145 "VBNET.ATG" +#line 2146 "VBNET.ATG" out embeddedStatement); -#line 2145 "VBNET.ATG" +#line 2146 "VBNET.ATG" ifStatement.TrueStatement.Add(embeddedStatement); } if (la.kind == 85) { lexer.NextToken(); if (StartOf(26)) { EmbeddedStatement( -#line 2147 "VBNET.ATG" +#line 2148 "VBNET.ATG" out embeddedStatement); } -#line 2149 "VBNET.ATG" +#line 2150 "VBNET.ATG" ifStatement.FalseStatement.Add(embeddedStatement); while (la.kind == 13) { lexer.NextToken(); EmbeddedStatement( -#line 2152 "VBNET.ATG" +#line 2153 "VBNET.ATG" out embeddedStatement); -#line 2153 "VBNET.ATG" +#line 2154 "VBNET.ATG" ifStatement.FalseStatement.Add(embeddedStatement); } } -#line 2156 "VBNET.ATG" +#line 2157 "VBNET.ATG" statement = ifStatement; } else SynErr(244); break; @@ -5658,43 +5659,43 @@ out embeddedStatement); lexer.NextToken(); } Expr( -#line 2159 "VBNET.ATG" +#line 2160 "VBNET.ATG" out expr); EndOfStmt(); -#line 2160 "VBNET.ATG" +#line 2161 "VBNET.ATG" ArrayList selectSections = new ArrayList(); Statement block = null; while (la.kind == 56) { -#line 2164 "VBNET.ATG" +#line 2165 "VBNET.ATG" ArrayList caseClauses = null; lexer.NextToken(); CaseClauses( -#line 2165 "VBNET.ATG" +#line 2166 "VBNET.ATG" out caseClauses); if ( -#line 2165 "VBNET.ATG" +#line 2166 "VBNET.ATG" IsNotStatementSeparator()) { lexer.NextToken(); } EndOfStmt(); -#line 2167 "VBNET.ATG" +#line 2168 "VBNET.ATG" SwitchSection selectSection = new SwitchSection(caseClauses); Block( -#line 2169 "VBNET.ATG" +#line 2170 "VBNET.ATG" out block); -#line 2171 "VBNET.ATG" +#line 2172 "VBNET.ATG" selectSection.Children = block.Children; selectSections.Add(selectSection); } -#line 2175 "VBNET.ATG" +#line 2176 "VBNET.ATG" statement = new SwitchStatement(expr, selectSections); Expect(87); Expect(155); @@ -5702,43 +5703,43 @@ out block); } case 134: { -#line 2177 "VBNET.ATG" +#line 2178 "VBNET.ATG" OnErrorStatement onErrorStatement = null; OnErrorStatement( -#line 2178 "VBNET.ATG" +#line 2179 "VBNET.ATG" out onErrorStatement); -#line 2178 "VBNET.ATG" +#line 2179 "VBNET.ATG" statement = onErrorStatement; break; } case 103: { -#line 2179 "VBNET.ATG" +#line 2180 "VBNET.ATG" GotoStatement goToStatement = null; GotoStatement( -#line 2180 "VBNET.ATG" +#line 2181 "VBNET.ATG" out goToStatement); -#line 2180 "VBNET.ATG" +#line 2181 "VBNET.ATG" statement = goToStatement; break; } case 153: { -#line 2181 "VBNET.ATG" +#line 2182 "VBNET.ATG" ResumeStatement resumeStatement = null; ResumeStatement( -#line 2182 "VBNET.ATG" +#line 2183 "VBNET.ATG" out resumeStatement); -#line 2182 "VBNET.ATG" +#line 2183 "VBNET.ATG" statement = resumeStatement; break; } case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 14: case 15: case 16: case 23: case 42: case 50: case 51: case 53: case 58: case 59: case 60: case 61: case 62: case 63: case 64: case 65: case 67: case 68: case 69: case 71: case 72: case 73: case 74: case 75: case 76: case 81: case 83: case 95: case 101: case 110: case 116: case 118: case 123: case 124: case 126: case 129: case 159: case 160: case 165: case 169: case 173: case 175: case 190: case 191: case 192: case 193: { -#line 2185 "VBNET.ATG" +#line 2186 "VBNET.ATG" Expression val = null; AssignmentOperatorType op; @@ -5746,25 +5747,25 @@ out resumeStatement); la.kind == Tokens.Not || la.kind == Tokens.Times; UnaryExpr( -#line 2191 "VBNET.ATG" +#line 2192 "VBNET.ATG" out expr); if (StartOf(28)) { AssignmentOperator( -#line 2193 "VBNET.ATG" +#line 2194 "VBNET.ATG" out op); Expr( -#line 2193 "VBNET.ATG" +#line 2194 "VBNET.ATG" out val); -#line 2193 "VBNET.ATG" +#line 2194 "VBNET.ATG" expr = new AssignmentExpression(expr, op, val); } else if (la.kind == 1 || la.kind == 13 || la.kind == 85) { -#line 2194 "VBNET.ATG" +#line 2195 "VBNET.ATG" if (mustBeAssignment) Error("error in assignment."); } else SynErr(245); -#line 2197 "VBNET.ATG" +#line 2198 "VBNET.ATG" // a field reference expression that stands alone is a // invocation expression without parantheses and arguments if(expr is FieldReferenceExpression) { @@ -5777,10 +5778,10 @@ out val); case 55: { lexer.NextToken(); UnaryExpr( -#line 2204 "VBNET.ATG" +#line 2205 "VBNET.ATG" out expr); -#line 2204 "VBNET.ATG" +#line 2205 "VBNET.ATG" statement = new StatementExpression(expr); break; } @@ -5788,7 +5789,7 @@ out expr); lexer.NextToken(); Identifier(); -#line 2206 "VBNET.ATG" +#line 2207 "VBNET.ATG" string resourcename = t.val, typeName; Statement resourceAquisition = null, block = null; @@ -5796,45 +5797,45 @@ out expr); if (la.kind == 126) { lexer.NextToken(); Qualident( -#line 2210 "VBNET.ATG" +#line 2211 "VBNET.ATG" out typeName); -#line 2210 "VBNET.ATG" +#line 2211 "VBNET.ATG" ArrayList initializer = null; if (la.kind == 23) { lexer.NextToken(); if (StartOf(16)) { ArgumentList( -#line 2210 "VBNET.ATG" +#line 2211 "VBNET.ATG" out initializer); } Expect(24); } -#line 2212 "VBNET.ATG" +#line 2213 "VBNET.ATG" resourceAquisition = new LocalVariableDeclaration(new VariableDeclaration(resourcename, new ArrayInitializerExpression(initializer), new TypeReference(typeName))); } else if (StartOf(9)) { Qualident( -#line 2215 "VBNET.ATG" +#line 2216 "VBNET.ATG" out typeName); Expect(11); Expr( -#line 2215 "VBNET.ATG" +#line 2216 "VBNET.ATG" out expr); -#line 2217 "VBNET.ATG" +#line 2218 "VBNET.ATG" resourceAquisition = new LocalVariableDeclaration(new VariableDeclaration(resourcename, expr, new TypeReference(typeName))); } else SynErr(246); Block( -#line 2220 "VBNET.ATG" +#line 2221 "VBNET.ATG" out block); Expect(87); Expect(188); -#line 2222 "VBNET.ATG" +#line 2223 "VBNET.ATG" statement = new UsingStatement(resourceAquisition, block); break; } @@ -5843,10 +5844,10 @@ out block); } void LocalDeclarationStatement( -#line 1930 "VBNET.ATG" +#line 1931 "VBNET.ATG" out Statement statement) { -#line 1932 "VBNET.ATG" +#line 1933 "VBNET.ATG" Modifiers m = new Modifiers(); LocalVariableDeclaration localVariableDeclaration; bool dimfound = false; @@ -5855,22 +5856,22 @@ out Statement statement) { if (la.kind == 70) { lexer.NextToken(); -#line 1938 "VBNET.ATG" +#line 1939 "VBNET.ATG" m.Add(Modifier.Const); } else if (la.kind == 161) { lexer.NextToken(); -#line 1939 "VBNET.ATG" +#line 1940 "VBNET.ATG" m.Add(Modifier.Static); } else { lexer.NextToken(); -#line 1940 "VBNET.ATG" +#line 1941 "VBNET.ATG" dimfound = true; } } -#line 1943 "VBNET.ATG" +#line 1944 "VBNET.ATG" if(dimfound && (m.Modifier & Modifier.Const) != 0) { Error("Dim is not allowed on constants."); } @@ -5883,137 +5884,137 @@ out Statement statement) { localVariableDeclaration.StartLocation = t.Location; VariableDeclarator( -#line 1954 "VBNET.ATG" +#line 1955 "VBNET.ATG" localVariableDeclaration.Variables); while (la.kind == 12) { lexer.NextToken(); VariableDeclarator( -#line 1955 "VBNET.ATG" +#line 1956 "VBNET.ATG" localVariableDeclaration.Variables); } -#line 1957 "VBNET.ATG" +#line 1958 "VBNET.ATG" statement = localVariableDeclaration; } void TryStatement( -#line 2415 "VBNET.ATG" +#line 2416 "VBNET.ATG" out Statement tryStatement) { -#line 2417 "VBNET.ATG" +#line 2418 "VBNET.ATG" Statement blockStmt = null, finallyStmt = null;ArrayList catchClauses = null; Expect(174); EndOfStmt(); Block( -#line 2420 "VBNET.ATG" +#line 2421 "VBNET.ATG" out blockStmt); if (la.kind == 57 || la.kind == 87 || la.kind == 96) { CatchClauses( -#line 2421 "VBNET.ATG" +#line 2422 "VBNET.ATG" out catchClauses); } if (la.kind == 96) { lexer.NextToken(); EndOfStmt(); Block( -#line 2422 "VBNET.ATG" +#line 2423 "VBNET.ATG" out finallyStmt); } Expect(87); Expect(174); -#line 2425 "VBNET.ATG" +#line 2426 "VBNET.ATG" tryStatement = new TryCatchStatement(blockStmt, catchClauses, finallyStmt); } void WithStatement( -#line 2393 "VBNET.ATG" +#line 2394 "VBNET.ATG" out Statement withStatement) { -#line 2395 "VBNET.ATG" +#line 2396 "VBNET.ATG" Statement blockStmt = null; Expression expr = null; Expect(182); -#line 2398 "VBNET.ATG" +#line 2399 "VBNET.ATG" Point start = t.Location; Expr( -#line 2399 "VBNET.ATG" +#line 2400 "VBNET.ATG" out expr); EndOfStmt(); -#line 2401 "VBNET.ATG" +#line 2402 "VBNET.ATG" withStatement = new WithStatement(expr); withStatement.StartLocation = start; withStatements.Push(withStatement); Block( -#line 2405 "VBNET.ATG" +#line 2406 "VBNET.ATG" out blockStmt); -#line 2407 "VBNET.ATG" +#line 2408 "VBNET.ATG" ((WithStatement)withStatement).Body = (BlockStatement)blockStmt; withStatements.Pop(); Expect(87); Expect(182); -#line 2411 "VBNET.ATG" +#line 2412 "VBNET.ATG" withStatement.EndLocation = t.Location; } void WhileOrUntil( -#line 2386 "VBNET.ATG" +#line 2387 "VBNET.ATG" out ConditionType conditionType) { -#line 2387 "VBNET.ATG" +#line 2388 "VBNET.ATG" conditionType = ConditionType.None; if (la.kind == 181) { lexer.NextToken(); -#line 2388 "VBNET.ATG" +#line 2389 "VBNET.ATG" conditionType = ConditionType.While; } else if (la.kind == 177) { lexer.NextToken(); -#line 2389 "VBNET.ATG" +#line 2390 "VBNET.ATG" conditionType = ConditionType.Until; } else SynErr(248); } void LoopControlVariable( -#line 2227 "VBNET.ATG" +#line 2228 "VBNET.ATG" out TypeReference type, out string name) { -#line 2228 "VBNET.ATG" +#line 2229 "VBNET.ATG" ArrayList arrayModifiers = null; type = null; Qualident( -#line 2232 "VBNET.ATG" +#line 2233 "VBNET.ATG" out name); if ( -#line 2233 "VBNET.ATG" +#line 2234 "VBNET.ATG" IsDims()) { ArrayTypeModifiers( -#line 2233 "VBNET.ATG" +#line 2234 "VBNET.ATG" out arrayModifiers); } if (la.kind == 47) { lexer.NextToken(); TypeName( -#line 2234 "VBNET.ATG" +#line 2235 "VBNET.ATG" out type); -#line 2234 "VBNET.ATG" +#line 2235 "VBNET.ATG" if (name.IndexOf('.') > 0) { Error("No type def for 'for each' member indexer allowed."); } } -#line 2236 "VBNET.ATG" +#line 2237 "VBNET.ATG" if (type != null) { if(type.RankSpecifier != null && arrayModifiers != null) { Error("array rank only allowed one time"); @@ -6031,48 +6032,48 @@ out type); } void CaseClauses( -#line 2346 "VBNET.ATG" +#line 2347 "VBNET.ATG" out ArrayList caseClauses) { -#line 2348 "VBNET.ATG" +#line 2349 "VBNET.ATG" caseClauses = new ArrayList(); CaseLabel caseClause = null; CaseClause( -#line 2351 "VBNET.ATG" +#line 2352 "VBNET.ATG" out caseClause); -#line 2351 "VBNET.ATG" +#line 2352 "VBNET.ATG" caseClauses.Add(caseClause); while (la.kind == 12) { lexer.NextToken(); CaseClause( -#line 2352 "VBNET.ATG" +#line 2353 "VBNET.ATG" out caseClause); -#line 2352 "VBNET.ATG" +#line 2353 "VBNET.ATG" caseClauses.Add(caseClause); } } void OnErrorStatement( -#line 2253 "VBNET.ATG" +#line 2254 "VBNET.ATG" out OnErrorStatement stmt) { -#line 2255 "VBNET.ATG" +#line 2256 "VBNET.ATG" stmt = null; GotoStatement goToStatement = null; Expect(134); Expect(91); if ( -#line 2261 "VBNET.ATG" +#line 2262 "VBNET.ATG" IsNegativeLabelName()) { Expect(103); Expect(15); Expect(5); -#line 2263 "VBNET.ATG" +#line 2264 "VBNET.ATG" long intLabel = Int64.Parse(t.val); if(intLabel != 1) { Error("invalid label in on error statement."); @@ -6081,10 +6082,10 @@ IsNegativeLabelName()) { } else if (la.kind == 103) { GotoStatement( -#line 2269 "VBNET.ATG" +#line 2270 "VBNET.ATG" out goToStatement); -#line 2271 "VBNET.ATG" +#line 2272 "VBNET.ATG" string val = goToStatement.Label; // if value is numeric, make sure that is 0 @@ -6101,63 +6102,63 @@ out goToStatement); lexer.NextToken(); Expect(127); -#line 2285 "VBNET.ATG" +#line 2286 "VBNET.ATG" stmt = new OnErrorStatement(new ResumeStatement(true)); } else SynErr(249); } void GotoStatement( -#line 2291 "VBNET.ATG" +#line 2292 "VBNET.ATG" out ICSharpCode.NRefactory.Parser.AST.GotoStatement goToStatement) { -#line 2293 "VBNET.ATG" +#line 2294 "VBNET.ATG" string label = String.Empty; Expect(103); LabelName( -#line 2296 "VBNET.ATG" +#line 2297 "VBNET.ATG" out label); -#line 2298 "VBNET.ATG" +#line 2299 "VBNET.ATG" goToStatement = new ICSharpCode.NRefactory.Parser.AST.GotoStatement(label); } void ResumeStatement( -#line 2335 "VBNET.ATG" +#line 2336 "VBNET.ATG" out ResumeStatement resumeStatement) { -#line 2337 "VBNET.ATG" +#line 2338 "VBNET.ATG" resumeStatement = null; string label = String.Empty; if ( -#line 2340 "VBNET.ATG" +#line 2341 "VBNET.ATG" IsResumeNext()) { Expect(153); Expect(127); -#line 2341 "VBNET.ATG" +#line 2342 "VBNET.ATG" resumeStatement = new ResumeStatement(true); } else if (la.kind == 153) { lexer.NextToken(); if (StartOf(29)) { LabelName( -#line 2342 "VBNET.ATG" +#line 2343 "VBNET.ATG" out label); } -#line 2342 "VBNET.ATG" +#line 2343 "VBNET.ATG" resumeStatement = new ResumeStatement(label); } else SynErr(250); } void CaseClause( -#line 2356 "VBNET.ATG" +#line 2357 "VBNET.ATG" out CaseLabel caseClause) { -#line 2358 "VBNET.ATG" +#line 2359 "VBNET.ATG" Expression expr = null; Expression sexpr = null; BinaryOperatorType op = BinaryOperatorType.None; @@ -6166,7 +6167,7 @@ out CaseLabel caseClause) { if (la.kind == 85) { lexer.NextToken(); -#line 2364 "VBNET.ATG" +#line 2365 "VBNET.ATG" caseClause = new CaseLabel(); } else if (StartOf(30)) { if (la.kind == 112) { @@ -6176,76 +6177,76 @@ out CaseLabel caseClause) { case 26: { lexer.NextToken(); -#line 2368 "VBNET.ATG" +#line 2369 "VBNET.ATG" op = BinaryOperatorType.LessThan; break; } case 25: { lexer.NextToken(); -#line 2369 "VBNET.ATG" +#line 2370 "VBNET.ATG" op = BinaryOperatorType.GreaterThan; break; } case 29: { lexer.NextToken(); -#line 2370 "VBNET.ATG" +#line 2371 "VBNET.ATG" op = BinaryOperatorType.LessThanOrEqual; break; } case 28: { lexer.NextToken(); -#line 2371 "VBNET.ATG" +#line 2372 "VBNET.ATG" op = BinaryOperatorType.GreaterThanOrEqual; break; } case 11: { lexer.NextToken(); -#line 2372 "VBNET.ATG" +#line 2373 "VBNET.ATG" op = BinaryOperatorType.Equality; break; } case 27: { lexer.NextToken(); -#line 2373 "VBNET.ATG" +#line 2374 "VBNET.ATG" op = BinaryOperatorType.InEquality; break; } default: SynErr(251); break; } Expr( -#line 2375 "VBNET.ATG" +#line 2376 "VBNET.ATG" out expr); -#line 2377 "VBNET.ATG" +#line 2378 "VBNET.ATG" caseClause = new CaseLabel(op, expr); } else if (StartOf(17)) { Expr( -#line 2379 "VBNET.ATG" +#line 2380 "VBNET.ATG" out expr); if (la.kind == 172) { lexer.NextToken(); Expr( -#line 2379 "VBNET.ATG" +#line 2380 "VBNET.ATG" out sexpr); } -#line 2381 "VBNET.ATG" +#line 2382 "VBNET.ATG" caseClause = new CaseLabel(expr, sexpr); } else SynErr(252); } void CatchClauses( -#line 2430 "VBNET.ATG" +#line 2431 "VBNET.ATG" out ArrayList catchClauses) { -#line 2432 "VBNET.ATG" +#line 2433 "VBNET.ATG" catchClauses = new ArrayList(); TypeReference type = null; Statement blockStmt = null; @@ -6257,27 +6258,27 @@ out ArrayList catchClauses) { if (StartOf(9)) { Identifier(); -#line 2440 "VBNET.ATG" +#line 2441 "VBNET.ATG" name = t.val; if (la.kind == 47) { lexer.NextToken(); TypeName( -#line 2440 "VBNET.ATG" +#line 2441 "VBNET.ATG" out type); } } if (la.kind == 180) { lexer.NextToken(); Expr( -#line 2441 "VBNET.ATG" +#line 2442 "VBNET.ATG" out expr); } EndOfStmt(); Block( -#line 2443 "VBNET.ATG" +#line 2444 "VBNET.ATG" out blockStmt); -#line 2444 "VBNET.ATG" +#line 2445 "VBNET.ATG" catchClauses.Add(new CatchClause(type, name, blockStmt, expr)); } } diff --git a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG index f8acf958b8..59f54656aa 100644 --- a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG +++ b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG @@ -1,5 +1,6 @@ using System.Drawing; using System.Collections; +using System.Collections.Generic; using System.Collections.Specialized; using System.Text; using ICSharpCode.NRefactory.Parser.AST; @@ -832,7 +833,7 @@ ClassBaseType StructureMemberDecl (. TypeReference type = null; ArrayList p = null; - Statement stmt = null; ArrayList variableDeclarators = new ArrayList(); + Statement stmt = null; List variableDeclarators = new List(); .)= NonModuleDeclaration | /* 9.2.1 */ @@ -1056,7 +1057,7 @@ StructureMemberDecl "Const" (. m.Add(Modifier.Const); .) (. FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier); - fd.StartLocation = t.Location;ArrayList constantDeclarators = new ArrayList(); + fd.StartLocation = t.Location;List constantDeclarators = new List(); .) ConstantDeclarator { "," ConstantDeclarator } @@ -1177,7 +1178,7 @@ SetAccessorDecl . /* 9.5 */ -ConstantDeclarator +ConstantDeclarator constantDeclaration> (. Expression expr = null; TypeReference type = null; @@ -1194,7 +1195,7 @@ ConstantDeclarator . /* 9.6 */ -VariableDeclarator +VariableDeclarator fieldDeclaration> (. Expression expr = null; TypeReference type = null;ArrayList rank = null;ArrayList dimension = null; @@ -1547,8 +1548,8 @@ RelationalExpr ShiftExpr (. outExpr = new BinaryOperatorExpression(outExpr, op, expr); .) | /* 11.5.3 */ - ("Is" (. op = BinaryOperatorType.IS; .) | - "IsNot" (. op = BinaryOperatorType.IsNot; .) ) + ("Is" (. op = BinaryOperatorType.ReferenceEquality; .) | + "IsNot" (. op = BinaryOperatorType.ReferenceInequality; .) ) Expr (. outExpr = new BinaryOperatorExpression(outExpr, op, expr); .) } . diff --git a/src/Libraries/NRefactory/Project/Src/Parser/Visitors/CSharpToVBNetConvertVisitor.cs b/src/Libraries/NRefactory/Project/Src/Parser/Visitors/CSharpToVBNetConvertVisitor.cs new file mode 100644 index 0000000000..f2665f5cd9 --- /dev/null +++ b/src/Libraries/NRefactory/Project/Src/Parser/Visitors/CSharpToVBNetConvertVisitor.cs @@ -0,0 +1,88 @@ +/* + * Created by SharpDevelop. + * User: Daniel Grunwald + * Date: 16.07.2005 + * Time: 16:32 + */ + +using System; +using System.Text; +using System.Collections; +using System.Collections.Generic; +using System.Diagnostics; + +using ICSharpCode.NRefactory.Parser; +using ICSharpCode.NRefactory.Parser.VB; +using ICSharpCode.NRefactory.Parser.AST; + +namespace ICSharpCode.NRefactory.Parser +{ + /// + /// This class converts C# constructs to their VB.NET equivalents. + /// + public class CSharpToVBNetConvertVisitor : AbstractASTVisitor + { + // The following conversions are implemented: + // Conflicting field/property names -> m_field + // a == null -> a Is Nothing + // a != null -> a Is Not Nothing + + // The following conversions should be implemented in the future: + // ForStatement -> ForNextStatement when for-loop is simple + // if (Event != null) Event(this, bla); -> RaiseEvent Event(this, bla) + + public override object Visit(BinaryOperatorExpression binaryOperatorExpression, object data) + { + if (binaryOperatorExpression.Op == BinaryOperatorType.Equality || binaryOperatorExpression.Op == BinaryOperatorType.InEquality) { + if (IsNullLiteralExpression(binaryOperatorExpression.Left)) { + Expression tmp = binaryOperatorExpression.Left; + binaryOperatorExpression.Left = binaryOperatorExpression.Right; + binaryOperatorExpression.Right = tmp; + } + if (IsNullLiteralExpression(binaryOperatorExpression.Right)) { + if (binaryOperatorExpression.Op == BinaryOperatorType.Equality) { + binaryOperatorExpression.Op = BinaryOperatorType.ReferenceEquality; + } else { + binaryOperatorExpression.Op = BinaryOperatorType.ReferenceInequality; + } + } + } + return base.Visit(binaryOperatorExpression, data); + } + + bool IsNullLiteralExpression(Expression expr) + { + PrimitiveExpression pe = expr as PrimitiveExpression; + if (pe == null) return false; + return pe.Value == null; + } + + public override object Visit(TypeDeclaration td, object data) + { + // Conflicting field/property names -> m_field + List properties = new List(); + foreach (object o in td.Children) { + PropertyDeclaration pd = o as PropertyDeclaration; + if (pd != null) { + properties.Add(pd.Name); + } + } + List conflicts = new List(); + foreach (object o in td.Children) { + FieldDeclaration fd = o as FieldDeclaration; + if (fd != null) { + foreach (VariableDeclaration var in fd.Fields) { + string name = var.Name; + foreach (string propertyName in properties) { + if (name.Equals(propertyName, StringComparison.InvariantCultureIgnoreCase)) { + conflicts.Add(var); + } + } + } + } + } + new PrefixFieldsVisitor(conflicts, "m_").Run(td); + return base.Visit(td, data); + } + } +} diff --git a/src/Libraries/NRefactory/Project/Src/Parser/Visitors/PrefixFieldsVisitor.cs b/src/Libraries/NRefactory/Project/Src/Parser/Visitors/PrefixFieldsVisitor.cs new file mode 100644 index 0000000000..bd7bf84a06 --- /dev/null +++ b/src/Libraries/NRefactory/Project/Src/Parser/Visitors/PrefixFieldsVisitor.cs @@ -0,0 +1,170 @@ +/* + * Created by SharpDevelop. + * User: Daniel Grunwald + * Date: 16.07.2005 + * Time: 16:33 + */ + +using System; +using System.Collections.Generic; +using ICSharpCode.NRefactory.Parser.AST; + +namespace ICSharpCode.NRefactory.Parser +{ + /// + /// Prefixes the names of the specified fields with the prefix and replaces the use. + /// + public class PrefixFieldsVisitor : AbstractASTVisitor + { + List fields; + List curBlock = new List(); + Stack> blocks = new Stack>(); + string prefix; + + public PrefixFieldsVisitor(List fields, string prefix) + { + this.fields = fields; + this.prefix = prefix; + } + + public void Run(TypeDeclaration typeDeclaration) + { + base.Visit(typeDeclaration, null); + foreach (VariableDeclaration decl in fields) { + decl.Name = prefix + decl.Name; + } + } + + public override object Visit(TypeDeclaration typeDeclaration, object data) + { + // TODO: treat fields of base types like locals + return base.Visit(typeDeclaration, data); + } + + public override object Visit(BlockStatement blockStatement, object data) + { + Push(); + object result = base.Visit(blockStatement, data); + Pop(); + return result; + } + + public override object Visit(MethodDeclaration methodDeclaration, object data) + { + Push(); + object result = base.Visit(methodDeclaration, data); + Pop(); + return result; + } + + public override object Visit(PropertyGetRegion p, object data) + { + Push(); + object result = base.Visit(p, data); + Pop(); + return result; + } + + public override object Visit(PropertySetRegion p, object data) + { + Push(); + object result = base.Visit(p, data); + Pop(); + return result; + } + + public override object Visit(ConstructorDeclaration constructorDeclaration, object data) + { + Push(); + object result = base.Visit(constructorDeclaration, data); + Pop(); + return result; + } + + private void Push() + { + blocks.Push(curBlock); + curBlock = new List(); + } + + private void Pop() + { + curBlock = blocks.Pop(); + } + + public override object Visit(LocalVariableDeclaration localVariableDeclaration, object data) + { + foreach (VariableDeclaration decl in localVariableDeclaration.Variables) { + //print("add variable ${decl.Name} to block") + curBlock.Add(decl.Name); + } + return base.Visit(localVariableDeclaration, data); + } + + public override object Visit(ParameterDeclarationExpression parameterDeclarationExpression, object data) + { + curBlock.Add(parameterDeclarationExpression.ParameterName); + //print("add parameter ${parameterDeclarationExpression.ParameterName} to block") + return base.Visit(parameterDeclarationExpression, data); + } + + public override object Visit(IdentifierExpression identifierExpression, object data) + { + string name = identifierExpression.Identifier; + foreach (VariableDeclaration var in fields) { + if (var.Name == name && !IsLocal(name)) { + identifierExpression.Identifier = prefix + name; + break; + } + } + return base.Visit(identifierExpression, data); + } + + public override object Visit(FieldReferenceExpression fieldReferenceExpression, object data) + { + if (fieldReferenceExpression.TargetObject is ThisReferenceExpression) { + string name = fieldReferenceExpression.FieldName; + foreach (VariableDeclaration var in fields) { + if (var.Name == name) { + fieldReferenceExpression.FieldName = prefix + name; + break; + } + } + } + return base.Visit(fieldReferenceExpression, data); + } + + bool IsLocal(string name) + { + foreach (List block in blocks) { + if (block.Contains(name)) + return true; + } + return curBlock.Contains(name); + } + + /* + public override object Visit(invocationExpression as InvocationExpression, object data) + { + // this method is a workaround for a bug in SharpRefactory + result = data + if invocationExpression.TargetObject != null: + result = invocationExpression.TargetObject.AcceptVisitor(self, data) + if invocationExpression.Parameters != null: + for n as INode in invocationExpression.Parameters: + n.AcceptVisitor(self, data) + return result + } + + public override object Visit(indexerExpression as IndexerExpression, object data) + { + // this method is a workaround for a bug in SharpRefactory + result = indexerExpression.TargetObject.AcceptVisitor(self, data) + for n as INode in indexerExpression.Indices { + n.AcceptVisitor(self, data) + } + return result + } + */ + } +} diff --git a/src/Libraries/NRefactory/Project/Src/Parser/Visitors/VBNetToCSharpConvertVisitor.cs b/src/Libraries/NRefactory/Project/Src/Parser/Visitors/VBNetToCSharpConvertVisitor.cs new file mode 100644 index 0000000000..b859fbced9 --- /dev/null +++ b/src/Libraries/NRefactory/Project/Src/Parser/Visitors/VBNetToCSharpConvertVisitor.cs @@ -0,0 +1,58 @@ +/* + * Created by SharpDevelop. + * User: Daniel Grunwald + * Date: 16.07.2005 + * Time: 18:24 + */ + +using System; +using System.Text; +using System.Collections; +using System.Collections.Generic; +using System.Diagnostics; + +using ICSharpCode.NRefactory.Parser; +using ICSharpCode.NRefactory.Parser.VB; +using ICSharpCode.NRefactory.Parser.AST; + +namespace ICSharpCode.NRefactory.Parser +{ + /// + /// This class converts VB.NET constructs to their C# equivalents. + /// + public class VBNetToCSharpConvertVisitor : AbstractASTVisitor + { + // The following conversions are implemented: + // MyBase.New() and MyClass.New() calls inside the constructor are converted to :base() and :this() + + // The following conversions should be implemented in the future: + // Public Event EventName(param As String) -> automatic delegate declaration + + public override object Visit(ConstructorDeclaration constructorDeclaration, object data) + { + // MyBase.New() and MyClass.New() calls inside the constructor are converted to :base() and :this() + BlockStatement body = constructorDeclaration.Body; + if (body != null && body.Children.Count > 0) { + StatementExpression se = body.Children[0] as StatementExpression; + if (se != null) { + InvocationExpression ie = se.Expression as InvocationExpression; + if (ie != null) { + FieldReferenceExpression fre = ie.TargetObject as FieldReferenceExpression; + if (fre != null && "New".Equals(fre.FieldName, StringComparison.InvariantCultureIgnoreCase)) { + if (fre.TargetObject is BaseReferenceExpression || fre.TargetObject is ClassReferenceExpression) { + body.Children.RemoveAt(0); + ConstructorInitializer ci = constructorDeclaration.ConstructorInitializer; + ci.Arguments = ie.Parameters; + if (fre.TargetObject is BaseReferenceExpression) + ci.ConstructorInitializerType = ConstructorInitializerType.Base; + else + ci.ConstructorInitializerType = ConstructorInitializerType.This; + } + } + } + } + } + return base.Visit(constructorDeclaration, data); + } + } +} diff --git a/src/Main/Base/Project/Src/Commands/VBConverter/CSharpConvertBuffer.cs b/src/Main/Base/Project/Src/Commands/VBConverter/CSharpConvertBuffer.cs index 8c1cc3c564..8bb7d4894c 100644 --- a/src/Main/Base/Project/Src/Commands/VBConverter/CSharpConvertBuffer.cs +++ b/src/Main/Base/Project/Src/Commands/VBConverter/CSharpConvertBuffer.cs @@ -43,6 +43,7 @@ namespace ICSharpCode.SharpDevelop.Commands ICSharpCode.NRefactory.PrettyPrinter.CSharpOutputVisitor vbv = new ICSharpCode.NRefactory.PrettyPrinter.CSharpOutputVisitor(); List specials = p.Lexer.SpecialTracker.CurrentSpecials; PreProcessingDirective.VBToCSharp(specials); + new VBNetToCSharpConvertVisitor().Visit(p.CompilationUnit, null); SpecialNodesInserter sni = new SpecialNodesInserter(specials, new SpecialOutputVisitor(vbv.OutputFormatter)); vbv.NodeTracker.NodeVisiting += sni.AcceptNodeStart; diff --git a/src/Main/Base/Project/Src/Commands/VBConverter/ConvertBuffer.cs b/src/Main/Base/Project/Src/Commands/VBConverter/ConvertBuffer.cs index 1e0ad8f32c..6113a20ef6 100644 --- a/src/Main/Base/Project/Src/Commands/VBConverter/ConvertBuffer.cs +++ b/src/Main/Base/Project/Src/Commands/VBConverter/ConvertBuffer.cs @@ -45,6 +45,7 @@ namespace ICSharpCode.SharpDevelop.Commands List specials = p.Lexer.SpecialTracker.CurrentSpecials; PreProcessingDirective.CSharpToVB(specials); + new CSharpToVBNetConvertVisitor().Visit(p.CompilationUnit, null); SpecialNodesInserter sni = new SpecialNodesInserter(specials, new SpecialOutputVisitor(vbv.OutputFormatter)); vbv.NodeTracker.NodeVisiting += sni.AcceptNodeStart;