You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7250 lines
159 KiB
7250 lines
159 KiB
|
|
#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; |
|
using ICSharpCode.NRefactory.Parser.VB; |
|
using ASTAttribute = ICSharpCode.NRefactory.Parser.AST.Attribute; |
|
/* |
|
Parser.frame file for NRefactory. |
|
*/ |
|
using System; |
|
using System.Reflection; |
|
|
|
namespace ICSharpCode.NRefactory.Parser.VB { |
|
|
|
|
|
|
|
internal class Parser : AbstractParser |
|
{ |
|
const int maxT = 201; |
|
|
|
const bool T = true; |
|
const bool x = false; |
|
|
|
|
|
#line 12 "VBNET.ATG" |
|
private string assemblyName = null; |
|
private Stack withStatements; |
|
private StringBuilder qualidentBuilder = new StringBuilder(); |
|
|
|
public string ContainingAssembly |
|
{ |
|
set { assemblyName = value; } |
|
} |
|
Token t |
|
{ |
|
get { |
|
return lexer.Token; |
|
} |
|
} |
|
Token la |
|
{ |
|
get { |
|
return lexer.LookAhead; |
|
} |
|
} |
|
|
|
/* Return the n-th token after the current lookahead token */ |
|
void StartPeek() |
|
{ |
|
lexer.StartPeek(); |
|
} |
|
|
|
Token Peek() |
|
{ |
|
return lexer.Peek(); |
|
} |
|
|
|
Token Peek (int n) |
|
{ |
|
lexer.StartPeek(); |
|
Token x = la; |
|
while (n > 0) { |
|
x = lexer.Peek(); |
|
n--; |
|
} |
|
return x; |
|
} |
|
|
|
public void Error(string s) |
|
{ |
|
if (errDist >= minErrDist) { |
|
errors.Error(la.line, la.col, s); |
|
} |
|
errDist = 0; |
|
} |
|
|
|
public override Expression ParseExpression() |
|
{ |
|
Expression expr; |
|
Expr(out expr); |
|
return expr; |
|
} |
|
|
|
bool LeaveBlock() |
|
{ |
|
int peek = Peek(1).kind; |
|
return Tokens.BlockSucc[la.kind] && (la.kind != Tokens.End || peek == Tokens.EOL || peek == Tokens.Colon); |
|
} |
|
|
|
/* True, if "." is followed by an ident */ |
|
bool DotAndIdentOrKw () { |
|
int peek = Peek(1).kind; |
|
return la.kind == Tokens.Dot && (peek == Tokens.Identifier || peek >= Tokens.AddHandler); |
|
} |
|
|
|
bool IsEndStmtAhead() |
|
{ |
|
int peek = Peek(1).kind; |
|
return la.kind == Tokens.End && (peek == Tokens.EOL || peek == Tokens.Colon); |
|
} |
|
|
|
bool IsNotClosingParenthesis() { |
|
return la.kind != Tokens.CloseParenthesis; |
|
} |
|
|
|
/* |
|
True, if ident is followed by "=" |
|
*/ |
|
bool IdentAndAsgn () { |
|
if(la.kind == Tokens.Identifier) { |
|
if(Peek(1).kind == Tokens.Assign) return true; |
|
if(Peek(1).kind == Tokens.Colon && Peek(2).kind == Tokens.Assign) return true; |
|
} |
|
return false; |
|
} |
|
|
|
/* |
|
True, if ident is followed by "=" or by ":" and "=" |
|
*/ |
|
bool IsNamedAssign() { |
|
// if(Peek(1).kind == Tokens.Assign) return true; // removed: not in the lang spec |
|
if(Peek(1).kind == Tokens.Colon && Peek(2).kind == Tokens.Assign) return true; |
|
return false; |
|
} |
|
|
|
bool IsObjectCreation() { |
|
return la.kind == Tokens.As && Peek(1).kind == Tokens.New; |
|
} |
|
|
|
/* |
|
True, if "<" is followed by the ident "assembly" or "module" |
|
*/ |
|
bool IsGlobalAttrTarget () { |
|
Token pt = Peek(1); |
|
return la.kind == Tokens.LessThan && ( pt.val.ToLower() == "assembly" || pt.val.ToLower() == "module"); |
|
} |
|
|
|
/* |
|
True if the next token is a "(" and is followed by "," or ")" |
|
*/ |
|
bool IsDims() |
|
{ |
|
int peek = Peek(1).kind; |
|
return la.kind == Tokens.OpenParenthesis |
|
&& (peek == Tokens.Comma || peek == Tokens.CloseParenthesis); |
|
} |
|
|
|
bool IsSize() |
|
{ |
|
return la.kind == Tokens.OpenParenthesis; |
|
} |
|
|
|
/* |
|
True, if the comma is not a trailing one, |
|
like the last one in: a, b, c, |
|
*/ |
|
bool NotFinalComma() { |
|
int peek = Peek(1).kind; |
|
return la.kind == Tokens.Comma && |
|
peek != Tokens.CloseCurlyBrace; |
|
} |
|
|
|
/* |
|
True, if the next token is "Else" and this one |
|
if followed by "If" |
|
*/ |
|
bool IsElseIf() |
|
{ |
|
int peek = Peek(1).kind; |
|
return la.kind == Tokens.Else && peek == Tokens.If; |
|
} |
|
|
|
/* |
|
True if the next token is goto and this one is |
|
followed by minus ("-") (this is allowd in in |
|
error clauses) |
|
*/ |
|
bool IsNegativeLabelName() |
|
{ |
|
int peek = Peek(1).kind; |
|
return la.kind == Tokens.GoTo && peek == Tokens.Minus; |
|
} |
|
|
|
/* |
|
True if the next statement is a "Resume next" statement |
|
*/ |
|
bool IsResumeNext() |
|
{ |
|
int peek = Peek(1).kind; |
|
return la.kind == Tokens.Resume && peek == Tokens.Next; |
|
} |
|
|
|
/* |
|
True, if ident/literal integer is followed by ":" |
|
*/ |
|
bool IsLabel() |
|
{ |
|
return (la.kind == Tokens.Identifier || la.kind == Tokens.LiteralInteger) |
|
&& Peek(1).kind == Tokens.Colon; |
|
} |
|
|
|
bool IsNotStatementSeparator() |
|
{ |
|
return la.kind == Tokens.Colon && Peek(1).kind == Tokens.EOL; |
|
} |
|
|
|
bool IsAssignment () |
|
{ |
|
return IdentAndAsgn(); |
|
} |
|
|
|
bool IsMustOverride(Modifiers m) |
|
{ |
|
return m.Contains(Modifier.Abstract); |
|
} |
|
|
|
/* |
|
True, if lookahead is a local attribute target specifier, |
|
i.e. one of "event", "return", "field", "method", |
|
"module", "param", "property", or "type" |
|
*/ |
|
bool IsLocalAttrTarget() { |
|
// TODO |
|
return false; |
|
} |
|
|
|
/* START AUTOGENERATED TOKENS SECTION */ |
|
|
|
|
|
/* |
|
|
|
*/ |
|
|
|
void VBNET() { |
|
|
|
#line 427 "VBNET.ATG" |
|
compilationUnit = new CompilationUnit(); |
|
withStatements = new Stack(); |
|
|
|
while (la.kind == 1) { |
|
lexer.NextToken(); |
|
} |
|
while (la.kind == 135) { |
|
OptionStmt(); |
|
} |
|
while (la.kind == 107) { |
|
ImportsStmt(); |
|
} |
|
while ( |
|
#line 433 "VBNET.ATG" |
|
IsGlobalAttrTarget()) { |
|
GlobalAttributeSection(); |
|
} |
|
while (StartOf(1)) { |
|
NamespaceMemberDecl(); |
|
} |
|
Expect(0); |
|
} |
|
|
|
void OptionStmt() { |
|
|
|
#line 438 "VBNET.ATG" |
|
INode node = null; bool val = true; |
|
Expect(135); |
|
|
|
#line 439 "VBNET.ATG" |
|
Point startPos = t.Location; |
|
if (la.kind == 94) { |
|
lexer.NextToken(); |
|
if (la.kind == 133 || la.kind == 134) { |
|
OptionValue( |
|
#line 441 "VBNET.ATG" |
|
ref val); |
|
} |
|
|
|
#line 442 "VBNET.ATG" |
|
node = new OptionDeclaration(OptionType.Explicit, val); |
|
} else if (la.kind == 164) { |
|
lexer.NextToken(); |
|
if (la.kind == 133 || la.kind == 134) { |
|
OptionValue( |
|
#line 444 "VBNET.ATG" |
|
ref val); |
|
} |
|
|
|
#line 445 "VBNET.ATG" |
|
node = new OptionDeclaration(OptionType.Strict, val); |
|
} else if (la.kind == 69) { |
|
lexer.NextToken(); |
|
if (la.kind == 50) { |
|
lexer.NextToken(); |
|
|
|
#line 447 "VBNET.ATG" |
|
node = new OptionDeclaration(OptionType.CompareBinary, val); |
|
} else if (la.kind == 169) { |
|
lexer.NextToken(); |
|
|
|
#line 448 "VBNET.ATG" |
|
node = new OptionDeclaration(OptionType.CompareText, val); |
|
} else SynErr(202); |
|
} else SynErr(203); |
|
EndOfStmt(); |
|
|
|
#line 453 "VBNET.ATG" |
|
node.StartLocation = startPos; |
|
node.EndLocation = t.Location; |
|
compilationUnit.AddChild(node); |
|
|
|
} |
|
|
|
void ImportsStmt() { |
|
|
|
#line 474 "VBNET.ATG" |
|
List<Using> usings = new List<Using>(); |
|
|
|
Expect(107); |
|
|
|
#line 478 "VBNET.ATG" |
|
Point startPos = t.Location; |
|
Using u; |
|
|
|
ImportClause( |
|
#line 481 "VBNET.ATG" |
|
out u); |
|
|
|
#line 481 "VBNET.ATG" |
|
usings.Add(u); |
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
ImportClause( |
|
#line 483 "VBNET.ATG" |
|
out u); |
|
|
|
#line 483 "VBNET.ATG" |
|
usings.Add(u); |
|
} |
|
EndOfStmt(); |
|
|
|
#line 487 "VBNET.ATG" |
|
UsingDeclaration usingDeclaration = new UsingDeclaration(usings); |
|
usingDeclaration.StartLocation = startPos; |
|
usingDeclaration.EndLocation = t.Location; |
|
compilationUnit.AddChild(usingDeclaration); |
|
|
|
} |
|
|
|
void GlobalAttributeSection() { |
|
|
|
#line 2008 "VBNET.ATG" |
|
Point startPos = t.Location; |
|
Expect(26); |
|
if (la.kind == 48) { |
|
lexer.NextToken(); |
|
} else if (la.kind == 120) { |
|
lexer.NextToken(); |
|
} else SynErr(204); |
|
|
|
#line 2010 "VBNET.ATG" |
|
string attributeTarget = t.val.ToLower(); |
|
List<ASTAttribute> attributes = new List<ASTAttribute>(); |
|
ASTAttribute attribute; |
|
|
|
Expect(13); |
|
Attribute( |
|
#line 2014 "VBNET.ATG" |
|
out attribute); |
|
|
|
#line 2014 "VBNET.ATG" |
|
attributes.Add(attribute); |
|
while ( |
|
#line 2015 "VBNET.ATG" |
|
NotFinalComma()) { |
|
if (la.kind == 12) { |
|
lexer.NextToken(); |
|
if (la.kind == 48) { |
|
lexer.NextToken(); |
|
} else if (la.kind == 120) { |
|
lexer.NextToken(); |
|
} else SynErr(205); |
|
Expect(13); |
|
} |
|
Attribute( |
|
#line 2015 "VBNET.ATG" |
|
out attribute); |
|
|
|
#line 2015 "VBNET.ATG" |
|
attributes.Add(attribute); |
|
} |
|
if (la.kind == 12) { |
|
lexer.NextToken(); |
|
} |
|
Expect(25); |
|
EndOfStmt(); |
|
|
|
#line 2020 "VBNET.ATG" |
|
AttributeSection section = new AttributeSection(attributeTarget, attributes); |
|
section.StartLocation = startPos; |
|
section.EndLocation = t.EndLocation; |
|
compilationUnit.AddChild(section); |
|
|
|
} |
|
|
|
void NamespaceMemberDecl() { |
|
|
|
#line 516 "VBNET.ATG" |
|
Modifiers m = new Modifiers(); |
|
AttributeSection section; |
|
List<AttributeSection> attributes = new List<AttributeSection>(); |
|
string qualident; |
|
|
|
if (la.kind == 125) { |
|
lexer.NextToken(); |
|
|
|
#line 523 "VBNET.ATG" |
|
Point startPos = t.Location; |
|
|
|
Qualident( |
|
#line 525 "VBNET.ATG" |
|
out qualident); |
|
|
|
#line 527 "VBNET.ATG" |
|
INode node = new NamespaceDeclaration(qualident); |
|
node.StartLocation = startPos; |
|
compilationUnit.AddChild(node); |
|
compilationUnit.BlockStart(node); |
|
|
|
Expect(1); |
|
NamespaceBody(); |
|
|
|
#line 535 "VBNET.ATG" |
|
node.EndLocation = t.Location; |
|
compilationUnit.BlockEnd(); |
|
|
|
} else if (StartOf(2)) { |
|
while (la.kind == 26) { |
|
AttributeSection( |
|
#line 539 "VBNET.ATG" |
|
out section); |
|
|
|
#line 539 "VBNET.ATG" |
|
attributes.Add(section); |
|
} |
|
while (StartOf(3)) { |
|
TypeModifier( |
|
#line 540 "VBNET.ATG" |
|
m); |
|
} |
|
NonModuleDeclaration( |
|
#line 540 "VBNET.ATG" |
|
m, attributes); |
|
} else SynErr(206); |
|
} |
|
|
|
void OptionValue( |
|
#line 459 "VBNET.ATG" |
|
ref bool val) { |
|
if (la.kind == 134) { |
|
lexer.NextToken(); |
|
|
|
#line 461 "VBNET.ATG" |
|
val = true; |
|
} else if (la.kind == 133) { |
|
lexer.NextToken(); |
|
|
|
#line 463 "VBNET.ATG" |
|
val = false; |
|
} else SynErr(207); |
|
} |
|
|
|
void EndOfStmt() { |
|
if (la.kind == 1) { |
|
lexer.NextToken(); |
|
} else if (la.kind == 13) { |
|
lexer.NextToken(); |
|
if (la.kind == 1) { |
|
lexer.NextToken(); |
|
} |
|
} else SynErr(208); |
|
} |
|
|
|
void ImportClause( |
|
#line 494 "VBNET.ATG" |
|
out Using u) { |
|
|
|
#line 496 "VBNET.ATG" |
|
string qualident = null; |
|
TypeReference aliasedType = null; |
|
u = null; |
|
|
|
Qualident( |
|
#line 500 "VBNET.ATG" |
|
out qualident); |
|
if (la.kind == 11) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 501 "VBNET.ATG" |
|
out aliasedType); |
|
} |
|
|
|
#line 503 "VBNET.ATG" |
|
if (qualident != null && qualident.Length > 0) { |
|
if (aliasedType != null) { |
|
u = new Using(qualident, aliasedType); |
|
} else { |
|
u = new Using(qualident); |
|
} |
|
} |
|
|
|
} |
|
|
|
void Qualident( |
|
#line 2732 "VBNET.ATG" |
|
out string qualident) { |
|
|
|
#line 2734 "VBNET.ATG" |
|
string name; |
|
qualidentBuilder.Length = 0; |
|
|
|
Identifier(); |
|
|
|
#line 2738 "VBNET.ATG" |
|
qualidentBuilder.Append(t.val); |
|
while ( |
|
#line 2739 "VBNET.ATG" |
|
DotAndIdentOrKw()) { |
|
Expect(10); |
|
IdentifierOrKeyword( |
|
#line 2739 "VBNET.ATG" |
|
out name); |
|
|
|
#line 2739 "VBNET.ATG" |
|
qualidentBuilder.Append('.'); qualidentBuilder.Append(name); |
|
} |
|
|
|
#line 2741 "VBNET.ATG" |
|
qualident = qualidentBuilder.ToString(); |
|
} |
|
|
|
void TypeName( |
|
#line 1928 "VBNET.ATG" |
|
out TypeReference typeref) { |
|
|
|
#line 1929 "VBNET.ATG" |
|
ArrayList rank = null; typeref = null; |
|
NonArrayTypeName( |
|
#line 1931 "VBNET.ATG" |
|
out typeref); |
|
ArrayTypeModifiers( |
|
#line 1932 "VBNET.ATG" |
|
out rank); |
|
|
|
#line 1934 "VBNET.ATG" |
|
if (rank != null && typeref != null) { |
|
typeref.RankSpecifier = (int[])rank.ToArray(typeof(int)); |
|
} |
|
|
|
} |
|
|
|
void NamespaceBody() { |
|
while (StartOf(1)) { |
|
NamespaceMemberDecl(); |
|
} |
|
Expect(87); |
|
Expect(125); |
|
Expect(1); |
|
} |
|
|
|
void AttributeSection( |
|
#line 2078 "VBNET.ATG" |
|
out AttributeSection section) { |
|
|
|
#line 2080 "VBNET.ATG" |
|
string attributeTarget = "";List<ASTAttribute> attributes = new List<ASTAttribute>(); |
|
ASTAttribute attribute; |
|
|
|
|
|
Expect(26); |
|
|
|
#line 2084 "VBNET.ATG" |
|
Point startPos = t.Location; |
|
if ( |
|
#line 2085 "VBNET.ATG" |
|
IsLocalAttrTarget()) { |
|
if (la.kind == 92) { |
|
lexer.NextToken(); |
|
|
|
#line 2086 "VBNET.ATG" |
|
attributeTarget = "event"; |
|
} else if (la.kind == 154) { |
|
lexer.NextToken(); |
|
|
|
#line 2087 "VBNET.ATG" |
|
attributeTarget = "return"; |
|
} else { |
|
Identifier(); |
|
|
|
#line 2090 "VBNET.ATG" |
|
string val = t.val.ToLower(); |
|
if (val != "field" || val != "method" || |
|
val != "module" || val != "param" || |
|
val != "property" || val != "type") |
|
Error("attribute target specifier (event, return, field," + |
|
"method, module, param, property, or type) expected"); |
|
attributeTarget = t.val; |
|
|
|
} |
|
Expect(13); |
|
} |
|
Attribute( |
|
#line 2100 "VBNET.ATG" |
|
out attribute); |
|
|
|
#line 2100 "VBNET.ATG" |
|
attributes.Add(attribute); |
|
while ( |
|
#line 2101 "VBNET.ATG" |
|
NotFinalComma()) { |
|
Expect(12); |
|
Attribute( |
|
#line 2101 "VBNET.ATG" |
|
out attribute); |
|
|
|
#line 2101 "VBNET.ATG" |
|
attributes.Add(attribute); |
|
} |
|
if (la.kind == 12) { |
|
lexer.NextToken(); |
|
} |
|
Expect(25); |
|
|
|
#line 2105 "VBNET.ATG" |
|
section = new AttributeSection(attributeTarget, attributes); |
|
section.StartLocation = startPos; |
|
section.EndLocation = t.EndLocation; |
|
|
|
} |
|
|
|
void TypeModifier( |
|
#line 2940 "VBNET.ATG" |
|
Modifiers m) { |
|
switch (la.kind) { |
|
case 148: { |
|
lexer.NextToken(); |
|
|
|
#line 2941 "VBNET.ATG" |
|
m.Add(Modifier.Public, t.Location); |
|
break; |
|
} |
|
case 147: { |
|
lexer.NextToken(); |
|
|
|
#line 2942 "VBNET.ATG" |
|
m.Add(Modifier.Protected, t.Location); |
|
break; |
|
} |
|
case 98: { |
|
lexer.NextToken(); |
|
|
|
#line 2943 "VBNET.ATG" |
|
m.Add(Modifier.Internal, t.Location); |
|
break; |
|
} |
|
case 145: { |
|
lexer.NextToken(); |
|
|
|
#line 2944 "VBNET.ATG" |
|
m.Add(Modifier.Private, t.Location); |
|
break; |
|
} |
|
case 158: { |
|
lexer.NextToken(); |
|
|
|
#line 2945 "VBNET.ATG" |
|
m.Add(Modifier.Static, t.Location); |
|
break; |
|
} |
|
case 157: { |
|
lexer.NextToken(); |
|
|
|
#line 2946 "VBNET.ATG" |
|
m.Add(Modifier.New, t.Location); |
|
break; |
|
} |
|
case 121: { |
|
lexer.NextToken(); |
|
|
|
#line 2947 "VBNET.ATG" |
|
m.Add(Modifier.Abstract, t.Location); |
|
break; |
|
} |
|
case 130: { |
|
lexer.NextToken(); |
|
|
|
#line 2948 "VBNET.ATG" |
|
m.Add(Modifier.Sealed, t.Location); |
|
break; |
|
} |
|
default: SynErr(209); break; |
|
} |
|
} |
|
|
|
void NonModuleDeclaration( |
|
#line 591 "VBNET.ATG" |
|
Modifiers m, List<AttributeSection> attributes) { |
|
|
|
#line 593 "VBNET.ATG" |
|
string name = null; |
|
TypeReference typeRef = null; |
|
List<TypeReference> baseInterfaces = null; |
|
|
|
switch (la.kind) { |
|
case 66: case 199: { |
|
|
|
#line 597 "VBNET.ATG" |
|
m.Check(Modifier.Classes); |
|
if (la.kind == 199) { |
|
lexer.NextToken(); |
|
|
|
#line 599 "VBNET.ATG" |
|
m.Add(Modifier.Partial, t.Location); |
|
} |
|
Expect(66); |
|
|
|
#line 601 "VBNET.ATG" |
|
TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes); |
|
newType.StartLocation = t.Location; |
|
compilationUnit.AddChild(newType); |
|
compilationUnit.BlockStart(newType); |
|
|
|
newType.Type = Types.Class; |
|
|
|
Identifier(); |
|
|
|
#line 608 "VBNET.ATG" |
|
newType.Name = t.val; |
|
TypeParameterList( |
|
#line 609 "VBNET.ATG" |
|
newType.Templates); |
|
EndOfStmt(); |
|
if (la.kind == 109) { |
|
ClassBaseType( |
|
#line 611 "VBNET.ATG" |
|
out typeRef); |
|
|
|
#line 611 "VBNET.ATG" |
|
newType.BaseTypes.Add(typeRef); |
|
} |
|
while (la.kind == 106) { |
|
TypeImplementsClause( |
|
#line 612 "VBNET.ATG" |
|
out baseInterfaces); |
|
|
|
#line 612 "VBNET.ATG" |
|
newType.BaseTypes.AddRange(baseInterfaces); |
|
} |
|
ClassBody( |
|
#line 613 "VBNET.ATG" |
|
newType); |
|
|
|
#line 615 "VBNET.ATG" |
|
compilationUnit.BlockEnd(); |
|
|
|
break; |
|
} |
|
case 120: { |
|
lexer.NextToken(); |
|
|
|
#line 619 "VBNET.ATG" |
|
m.Check(Modifier.VBModules); |
|
TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes); |
|
compilationUnit.AddChild(newType); |
|
compilationUnit.BlockStart(newType); |
|
newType.StartLocation = m.GetDeclarationLocation(t.Location); |
|
newType.Type = Types.Module; |
|
|
|
Identifier(); |
|
|
|
#line 626 "VBNET.ATG" |
|
newType.Name = t.val; |
|
Expect(1); |
|
ModuleBody( |
|
#line 628 "VBNET.ATG" |
|
newType); |
|
|
|
#line 630 "VBNET.ATG" |
|
compilationUnit.BlockEnd(); |
|
|
|
break; |
|
} |
|
case 166: { |
|
lexer.NextToken(); |
|
|
|
#line 634 "VBNET.ATG" |
|
m.Check(Modifier.VBStructures); |
|
TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes); |
|
compilationUnit.AddChild(newType); |
|
compilationUnit.BlockStart(newType); |
|
newType.StartLocation = m.GetDeclarationLocation(t.Location); |
|
newType.Type = Types.Struct; |
|
|
|
Identifier(); |
|
|
|
#line 641 "VBNET.ATG" |
|
newType.Name = t.val; |
|
TypeParameterList( |
|
#line 642 "VBNET.ATG" |
|
newType.Templates); |
|
Expect(1); |
|
while (la.kind == 106) { |
|
TypeImplementsClause( |
|
#line 643 "VBNET.ATG" |
|
out baseInterfaces); |
|
|
|
#line 643 "VBNET.ATG" |
|
newType.BaseTypes.AddRange(baseInterfaces); |
|
} |
|
StructureBody( |
|
#line 644 "VBNET.ATG" |
|
newType); |
|
|
|
#line 646 "VBNET.ATG" |
|
compilationUnit.BlockEnd(); |
|
|
|
break; |
|
} |
|
case 89: { |
|
lexer.NextToken(); |
|
|
|
#line 651 "VBNET.ATG" |
|
m.Check(Modifier.VBEnums); |
|
TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes); |
|
newType.StartLocation = m.GetDeclarationLocation(t.Location); |
|
compilationUnit.AddChild(newType); |
|
compilationUnit.BlockStart(newType); |
|
|
|
newType.Type = Types.Enum; |
|
|
|
Identifier(); |
|
|
|
#line 659 "VBNET.ATG" |
|
newType.Name = t.val; |
|
if (la.kind == 47) { |
|
lexer.NextToken(); |
|
PrimitiveTypeName( |
|
#line 660 "VBNET.ATG" |
|
out name); |
|
|
|
#line 660 "VBNET.ATG" |
|
newType.BaseTypes.Add(new TypeReference(name)); |
|
} |
|
Expect(1); |
|
EnumBody( |
|
#line 662 "VBNET.ATG" |
|
newType); |
|
|
|
#line 664 "VBNET.ATG" |
|
compilationUnit.BlockEnd(); |
|
|
|
break; |
|
} |
|
case 111: { |
|
lexer.NextToken(); |
|
|
|
#line 669 "VBNET.ATG" |
|
m.Check(Modifier.VBInterfacs); |
|
TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes); |
|
newType.StartLocation = m.GetDeclarationLocation(t.Location); |
|
compilationUnit.AddChild(newType); |
|
compilationUnit.BlockStart(newType); |
|
newType.Type = Types.Interface; |
|
|
|
Identifier(); |
|
|
|
#line 676 "VBNET.ATG" |
|
newType.Name = t.val; |
|
TypeParameterList( |
|
#line 677 "VBNET.ATG" |
|
newType.Templates); |
|
EndOfStmt(); |
|
while (la.kind == 109) { |
|
InterfaceBase( |
|
#line 678 "VBNET.ATG" |
|
out baseInterfaces); |
|
|
|
#line 678 "VBNET.ATG" |
|
newType.BaseTypes.AddRange(baseInterfaces); |
|
} |
|
InterfaceBody( |
|
#line 679 "VBNET.ATG" |
|
newType); |
|
|
|
#line 681 "VBNET.ATG" |
|
compilationUnit.BlockEnd(); |
|
|
|
break; |
|
} |
|
case 79: { |
|
lexer.NextToken(); |
|
|
|
#line 686 "VBNET.ATG" |
|
m.Check(Modifier.VBDelegates); |
|
DelegateDeclaration delegateDeclr = new DelegateDeclaration(m.Modifier, attributes); |
|
delegateDeclr.ReturnType = new TypeReference("", "System.Void"); |
|
delegateDeclr.StartLocation = m.GetDeclarationLocation(t.Location); |
|
List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>(); |
|
|
|
if (la.kind == 167) { |
|
lexer.NextToken(); |
|
Identifier(); |
|
|
|
#line 693 "VBNET.ATG" |
|
delegateDeclr.Name = t.val; |
|
TypeParameterList( |
|
#line 694 "VBNET.ATG" |
|
delegateDeclr.Templates); |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(4)) { |
|
FormalParameterList( |
|
#line 695 "VBNET.ATG" |
|
p); |
|
} |
|
Expect(24); |
|
|
|
#line 695 "VBNET.ATG" |
|
delegateDeclr.Parameters = p; |
|
} |
|
} else if (la.kind == 99) { |
|
lexer.NextToken(); |
|
Identifier(); |
|
|
|
#line 697 "VBNET.ATG" |
|
delegateDeclr.Name = t.val; |
|
TypeParameterList( |
|
#line 698 "VBNET.ATG" |
|
delegateDeclr.Templates); |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(4)) { |
|
FormalParameterList( |
|
#line 699 "VBNET.ATG" |
|
p); |
|
} |
|
Expect(24); |
|
|
|
#line 699 "VBNET.ATG" |
|
delegateDeclr.Parameters = p; |
|
} |
|
if (la.kind == 47) { |
|
lexer.NextToken(); |
|
|
|
#line 700 "VBNET.ATG" |
|
TypeReference type; |
|
TypeName( |
|
#line 700 "VBNET.ATG" |
|
out type); |
|
|
|
#line 700 "VBNET.ATG" |
|
delegateDeclr.ReturnType = type; |
|
} |
|
} else SynErr(210); |
|
|
|
#line 702 "VBNET.ATG" |
|
delegateDeclr.EndLocation = t.EndLocation; |
|
Expect(1); |
|
|
|
#line 705 "VBNET.ATG" |
|
compilationUnit.AddChild(delegateDeclr); |
|
|
|
break; |
|
} |
|
default: SynErr(211); break; |
|
} |
|
} |
|
|
|
void TypeParameterList( |
|
#line 544 "VBNET.ATG" |
|
List<TemplateDefinition> templates) { |
|
|
|
#line 546 "VBNET.ATG" |
|
TemplateDefinition template; |
|
|
|
if ( |
|
#line 549 "VBNET.ATG" |
|
la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) { |
|
lexer.NextToken(); |
|
Expect(196); |
|
TypeParameter( |
|
#line 550 "VBNET.ATG" |
|
out template); |
|
|
|
#line 552 "VBNET.ATG" |
|
if (template != null) templates.Add(template); |
|
|
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
TypeParameter( |
|
#line 555 "VBNET.ATG" |
|
out template); |
|
|
|
#line 557 "VBNET.ATG" |
|
if (template != null) templates.Add(template); |
|
|
|
} |
|
Expect(24); |
|
} |
|
} |
|
|
|
void TypeParameter( |
|
#line 565 "VBNET.ATG" |
|
out TemplateDefinition template) { |
|
Identifier(); |
|
|
|
#line 567 "VBNET.ATG" |
|
template = new TemplateDefinition(t.val, null); |
|
if (la.kind == 47) { |
|
TypeParameterConstraints( |
|
#line 568 "VBNET.ATG" |
|
template); |
|
} |
|
} |
|
|
|
void Identifier() { |
|
if (la.kind == 2) { |
|
lexer.NextToken(); |
|
} else if (la.kind == 169) { |
|
lexer.NextToken(); |
|
} else if (la.kind == 50) { |
|
lexer.NextToken(); |
|
} else if (la.kind == 69) { |
|
lexer.NextToken(); |
|
} else SynErr(212); |
|
} |
|
|
|
void TypeParameterConstraints( |
|
#line 572 "VBNET.ATG" |
|
TemplateDefinition template) { |
|
|
|
#line 574 "VBNET.ATG" |
|
TypeReference constraint; |
|
|
|
Expect(47); |
|
if (la.kind == 21) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 580 "VBNET.ATG" |
|
out constraint); |
|
|
|
#line 580 "VBNET.ATG" |
|
if (constraint != null) { template.Bases.Add(constraint); } |
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 583 "VBNET.ATG" |
|
out constraint); |
|
|
|
#line 583 "VBNET.ATG" |
|
if (constraint != null) { template.Bases.Add(constraint); } |
|
} |
|
Expect(22); |
|
} else if (StartOf(5)) { |
|
TypeName( |
|
#line 586 "VBNET.ATG" |
|
out constraint); |
|
|
|
#line 586 "VBNET.ATG" |
|
if (constraint != null) { template.Bases.Add(constraint); } |
|
} else SynErr(213); |
|
} |
|
|
|
void ClassBaseType( |
|
#line 882 "VBNET.ATG" |
|
out TypeReference typeRef) { |
|
|
|
#line 884 "VBNET.ATG" |
|
typeRef = null; |
|
|
|
Expect(109); |
|
TypeName( |
|
#line 887 "VBNET.ATG" |
|
out typeRef); |
|
EndOfStmt(); |
|
} |
|
|
|
void TypeImplementsClause( |
|
#line 1581 "VBNET.ATG" |
|
out List<TypeReference> baseInterfaces) { |
|
|
|
#line 1583 "VBNET.ATG" |
|
baseInterfaces = new List<TypeReference>(); |
|
TypeReference type = null; |
|
|
|
Expect(106); |
|
TypeName( |
|
#line 1586 "VBNET.ATG" |
|
out type); |
|
|
|
#line 1588 "VBNET.ATG" |
|
baseInterfaces.Add(type); |
|
|
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 1591 "VBNET.ATG" |
|
out type); |
|
|
|
#line 1592 "VBNET.ATG" |
|
baseInterfaces.Add(type); |
|
} |
|
EndOfStmt(); |
|
} |
|
|
|
void ClassBody( |
|
#line 715 "VBNET.ATG" |
|
TypeDeclaration newType) { |
|
|
|
#line 716 "VBNET.ATG" |
|
AttributeSection section; |
|
while (StartOf(6)) { |
|
|
|
#line 718 "VBNET.ATG" |
|
List<AttributeSection> attributes = new List<AttributeSection>(); |
|
Modifiers m = new Modifiers(); |
|
|
|
while (la.kind == 26) { |
|
AttributeSection( |
|
#line 721 "VBNET.ATG" |
|
out section); |
|
|
|
#line 721 "VBNET.ATG" |
|
attributes.Add(section); |
|
} |
|
while (StartOf(7)) { |
|
MemberModifier( |
|
#line 722 "VBNET.ATG" |
|
m); |
|
} |
|
ClassMemberDecl( |
|
#line 723 "VBNET.ATG" |
|
m, attributes); |
|
} |
|
Expect(87); |
|
Expect(66); |
|
|
|
#line 725 "VBNET.ATG" |
|
newType.EndLocation = t.EndLocation; |
|
Expect(1); |
|
} |
|
|
|
void ModuleBody( |
|
#line 744 "VBNET.ATG" |
|
TypeDeclaration newType) { |
|
|
|
#line 745 "VBNET.ATG" |
|
AttributeSection section; |
|
while (StartOf(6)) { |
|
|
|
#line 747 "VBNET.ATG" |
|
List<AttributeSection> attributes = new List<AttributeSection>(); |
|
Modifiers m = new Modifiers(); |
|
|
|
while (la.kind == 26) { |
|
AttributeSection( |
|
#line 750 "VBNET.ATG" |
|
out section); |
|
|
|
#line 750 "VBNET.ATG" |
|
attributes.Add(section); |
|
} |
|
while (StartOf(7)) { |
|
MemberModifier( |
|
#line 751 "VBNET.ATG" |
|
m); |
|
} |
|
ClassMemberDecl( |
|
#line 752 "VBNET.ATG" |
|
m, attributes); |
|
} |
|
Expect(87); |
|
Expect(120); |
|
|
|
#line 754 "VBNET.ATG" |
|
newType.EndLocation = t.EndLocation; |
|
Expect(1); |
|
} |
|
|
|
void StructureBody( |
|
#line 729 "VBNET.ATG" |
|
TypeDeclaration newType) { |
|
|
|
#line 730 "VBNET.ATG" |
|
AttributeSection section; |
|
while (StartOf(6)) { |
|
|
|
#line 732 "VBNET.ATG" |
|
List<AttributeSection> attributes = new List<AttributeSection>(); |
|
Modifiers m = new Modifiers(); |
|
|
|
while (la.kind == 26) { |
|
AttributeSection( |
|
#line 735 "VBNET.ATG" |
|
out section); |
|
|
|
#line 735 "VBNET.ATG" |
|
attributes.Add(section); |
|
} |
|
while (StartOf(7)) { |
|
MemberModifier( |
|
#line 736 "VBNET.ATG" |
|
m); |
|
} |
|
StructureMemberDecl( |
|
#line 737 "VBNET.ATG" |
|
m, attributes); |
|
} |
|
Expect(87); |
|
Expect(166); |
|
|
|
#line 739 "VBNET.ATG" |
|
newType.EndLocation = t.EndLocation; |
|
Expect(1); |
|
} |
|
|
|
void PrimitiveTypeName( |
|
#line 2914 "VBNET.ATG" |
|
out string type) { |
|
|
|
#line 2915 "VBNET.ATG" |
|
type = String.Empty; |
|
switch (la.kind) { |
|
case 51: { |
|
lexer.NextToken(); |
|
|
|
#line 2916 "VBNET.ATG" |
|
type = "Boolean"; |
|
break; |
|
} |
|
case 75: { |
|
lexer.NextToken(); |
|
|
|
#line 2917 "VBNET.ATG" |
|
type = "Date"; |
|
break; |
|
} |
|
case 64: { |
|
lexer.NextToken(); |
|
|
|
#line 2918 "VBNET.ATG" |
|
type = "Char"; |
|
break; |
|
} |
|
case 165: { |
|
lexer.NextToken(); |
|
|
|
#line 2919 "VBNET.ATG" |
|
type = "String"; |
|
break; |
|
} |
|
case 76: { |
|
lexer.NextToken(); |
|
|
|
#line 2920 "VBNET.ATG" |
|
type = "Decimal"; |
|
break; |
|
} |
|
case 53: { |
|
lexer.NextToken(); |
|
|
|
#line 2921 "VBNET.ATG" |
|
type = "Byte"; |
|
break; |
|
} |
|
case 159: { |
|
lexer.NextToken(); |
|
|
|
#line 2922 "VBNET.ATG" |
|
type = "Short"; |
|
break; |
|
} |
|
case 110: { |
|
lexer.NextToken(); |
|
|
|
#line 2923 "VBNET.ATG" |
|
type = "Integer"; |
|
break; |
|
} |
|
case 116: { |
|
lexer.NextToken(); |
|
|
|
#line 2924 "VBNET.ATG" |
|
type = "Long"; |
|
break; |
|
} |
|
case 160: { |
|
lexer.NextToken(); |
|
|
|
#line 2925 "VBNET.ATG" |
|
type = "Single"; |
|
break; |
|
} |
|
case 83: { |
|
lexer.NextToken(); |
|
|
|
#line 2926 "VBNET.ATG" |
|
type = "Double"; |
|
break; |
|
} |
|
case 191: { |
|
lexer.NextToken(); |
|
|
|
#line 2927 "VBNET.ATG" |
|
type = "UInteger"; |
|
break; |
|
} |
|
case 192: { |
|
lexer.NextToken(); |
|
|
|
#line 2928 "VBNET.ATG" |
|
type = "ULong"; |
|
break; |
|
} |
|
case 193: { |
|
lexer.NextToken(); |
|
|
|
#line 2929 "VBNET.ATG" |
|
type = "UShort"; |
|
break; |
|
} |
|
case 190: { |
|
lexer.NextToken(); |
|
|
|
#line 2930 "VBNET.ATG" |
|
type = "SByte"; |
|
break; |
|
} |
|
default: SynErr(214); break; |
|
} |
|
} |
|
|
|
void EnumBody( |
|
#line 758 "VBNET.ATG" |
|
TypeDeclaration newType) { |
|
|
|
#line 759 "VBNET.ATG" |
|
FieldDeclaration f; |
|
while (StartOf(8)) { |
|
EnumMemberDecl( |
|
#line 761 "VBNET.ATG" |
|
out f); |
|
|
|
#line 761 "VBNET.ATG" |
|
compilationUnit.AddChild(f); |
|
} |
|
Expect(87); |
|
Expect(89); |
|
|
|
#line 763 "VBNET.ATG" |
|
newType.EndLocation = t.EndLocation; |
|
Expect(1); |
|
} |
|
|
|
void InterfaceBase( |
|
#line 1566 "VBNET.ATG" |
|
out List<TypeReference> bases) { |
|
|
|
#line 1568 "VBNET.ATG" |
|
TypeReference type; |
|
bases = new List<TypeReference>(); |
|
|
|
Expect(109); |
|
TypeName( |
|
#line 1572 "VBNET.ATG" |
|
out type); |
|
|
|
#line 1572 "VBNET.ATG" |
|
bases.Add(type); |
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 1575 "VBNET.ATG" |
|
out type); |
|
|
|
#line 1575 "VBNET.ATG" |
|
bases.Add(type); |
|
} |
|
Expect(1); |
|
} |
|
|
|
void InterfaceBody( |
|
#line 767 "VBNET.ATG" |
|
TypeDeclaration newType) { |
|
while (StartOf(9)) { |
|
InterfaceMemberDecl(); |
|
} |
|
Expect(87); |
|
Expect(111); |
|
|
|
#line 769 "VBNET.ATG" |
|
newType.EndLocation = t.EndLocation; |
|
Expect(1); |
|
} |
|
|
|
void FormalParameterList( |
|
#line 2112 "VBNET.ATG" |
|
List<ParameterDeclarationExpression> parameter) { |
|
|
|
#line 2114 "VBNET.ATG" |
|
ParameterDeclarationExpression p; |
|
AttributeSection section; |
|
List<AttributeSection> attributes = new List<AttributeSection>(); |
|
|
|
while (la.kind == 26) { |
|
AttributeSection( |
|
#line 2118 "VBNET.ATG" |
|
out section); |
|
|
|
#line 2118 "VBNET.ATG" |
|
attributes.Add(section); |
|
} |
|
FormalParameter( |
|
#line 2120 "VBNET.ATG" |
|
out p); |
|
|
|
#line 2122 "VBNET.ATG" |
|
bool paramsFound = false; |
|
p.Attributes = attributes; |
|
parameter.Add(p); |
|
|
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
|
|
#line 2127 "VBNET.ATG" |
|
if (paramsFound) Error("params array must be at end of parameter list"); |
|
while (la.kind == 26) { |
|
AttributeSection( |
|
#line 2128 "VBNET.ATG" |
|
out section); |
|
|
|
#line 2128 "VBNET.ATG" |
|
attributes.Add(section); |
|
} |
|
FormalParameter( |
|
#line 2130 "VBNET.ATG" |
|
out p); |
|
|
|
#line 2130 "VBNET.ATG" |
|
p.Attributes = attributes; parameter.Add(p); |
|
} |
|
} |
|
|
|
void MemberModifier( |
|
#line 2951 "VBNET.ATG" |
|
Modifiers m) { |
|
switch (la.kind) { |
|
case 121: { |
|
lexer.NextToken(); |
|
|
|
#line 2952 "VBNET.ATG" |
|
m.Add(Modifier.Abstract, t.Location); |
|
break; |
|
} |
|
case 78: { |
|
lexer.NextToken(); |
|
|
|
#line 2953 "VBNET.ATG" |
|
m.Add(Modifier.Default, t.Location); |
|
break; |
|
} |
|
case 98: { |
|
lexer.NextToken(); |
|
|
|
#line 2954 "VBNET.ATG" |
|
m.Add(Modifier.Internal, t.Location); |
|
break; |
|
} |
|
case 157: { |
|
lexer.NextToken(); |
|
|
|
#line 2955 "VBNET.ATG" |
|
m.Add(Modifier.New, t.Location); |
|
break; |
|
} |
|
case 142: { |
|
lexer.NextToken(); |
|
|
|
#line 2956 "VBNET.ATG" |
|
m.Add(Modifier.Override, t.Location); |
|
break; |
|
} |
|
case 122: { |
|
lexer.NextToken(); |
|
|
|
#line 2957 "VBNET.ATG" |
|
m.Add(Modifier.Abstract, t.Location); |
|
break; |
|
} |
|
case 145: { |
|
lexer.NextToken(); |
|
|
|
#line 2958 "VBNET.ATG" |
|
m.Add(Modifier.Private, t.Location); |
|
break; |
|
} |
|
case 147: { |
|
lexer.NextToken(); |
|
|
|
#line 2959 "VBNET.ATG" |
|
m.Add(Modifier.Protected, t.Location); |
|
break; |
|
} |
|
case 148: { |
|
lexer.NextToken(); |
|
|
|
#line 2960 "VBNET.ATG" |
|
m.Add(Modifier.Public, t.Location); |
|
break; |
|
} |
|
case 130: { |
|
lexer.NextToken(); |
|
|
|
#line 2961 "VBNET.ATG" |
|
m.Add(Modifier.Sealed, t.Location); |
|
break; |
|
} |
|
case 131: { |
|
lexer.NextToken(); |
|
|
|
#line 2962 "VBNET.ATG" |
|
m.Add(Modifier.Sealed, t.Location); |
|
break; |
|
} |
|
case 158: { |
|
lexer.NextToken(); |
|
|
|
#line 2963 "VBNET.ATG" |
|
m.Add(Modifier.Static, t.Location); |
|
break; |
|
} |
|
case 140: { |
|
lexer.NextToken(); |
|
|
|
#line 2964 "VBNET.ATG" |
|
m.Add(Modifier.Virtual, t.Location); |
|
break; |
|
} |
|
case 139: { |
|
lexer.NextToken(); |
|
|
|
#line 2965 "VBNET.ATG" |
|
m.Add(Modifier.Overloads, t.Location); |
|
break; |
|
} |
|
case 150: { |
|
lexer.NextToken(); |
|
|
|
#line 2966 "VBNET.ATG" |
|
|
|
break; |
|
} |
|
case 184: { |
|
lexer.NextToken(); |
|
|
|
#line 2967 "VBNET.ATG" |
|
|
|
break; |
|
} |
|
case 183: { |
|
lexer.NextToken(); |
|
|
|
#line 2968 "VBNET.ATG" |
|
m.Add(Modifier.WithEvents, t.Location); |
|
break; |
|
} |
|
case 80: { |
|
lexer.NextToken(); |
|
|
|
#line 2969 "VBNET.ATG" |
|
m.Add(Modifier.Dim, t.Location); |
|
break; |
|
} |
|
case 198: { |
|
lexer.NextToken(); |
|
|
|
#line 2970 "VBNET.ATG" |
|
m.Add(Modifier.Widening, t.Location); |
|
break; |
|
} |
|
case 197: { |
|
lexer.NextToken(); |
|
|
|
#line 2971 "VBNET.ATG" |
|
m.Add(Modifier.Narrowing, t.Location); |
|
break; |
|
} |
|
default: SynErr(215); break; |
|
} |
|
} |
|
|
|
void ClassMemberDecl( |
|
#line 878 "VBNET.ATG" |
|
Modifiers m, List<AttributeSection> attributes) { |
|
StructureMemberDecl( |
|
#line 879 "VBNET.ATG" |
|
m, attributes); |
|
} |
|
|
|
void StructureMemberDecl( |
|
#line 892 "VBNET.ATG" |
|
Modifiers m, List<AttributeSection> attributes) { |
|
|
|
#line 894 "VBNET.ATG" |
|
TypeReference type = null; |
|
List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>(); |
|
Statement stmt = null; |
|
List<VariableDeclaration> variableDeclarators = new List<VariableDeclaration>(); |
|
List<TemplateDefinition> templates = new List<TemplateDefinition>(); |
|
|
|
switch (la.kind) { |
|
case 66: case 79: case 89: case 111: case 120: case 166: case 199: { |
|
NonModuleDeclaration( |
|
#line 900 "VBNET.ATG" |
|
m, attributes); |
|
break; |
|
} |
|
case 167: { |
|
lexer.NextToken(); |
|
|
|
#line 904 "VBNET.ATG" |
|
Point startPos = t.Location; |
|
|
|
if (StartOf(10)) { |
|
|
|
#line 908 "VBNET.ATG" |
|
string name = String.Empty; |
|
MethodDeclaration methodDeclaration; ArrayList handlesClause = null; ArrayList implementsClause = null; |
|
|
|
Identifier(); |
|
|
|
#line 913 "VBNET.ATG" |
|
name = t.val; |
|
m.Check(Modifier.VBMethods); |
|
|
|
TypeParameterList( |
|
#line 916 "VBNET.ATG" |
|
templates); |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(4)) { |
|
FormalParameterList( |
|
#line 917 "VBNET.ATG" |
|
p); |
|
} |
|
Expect(24); |
|
} |
|
if (la.kind == 104 || la.kind == 106) { |
|
if (la.kind == 106) { |
|
ImplementsClause( |
|
#line 920 "VBNET.ATG" |
|
out implementsClause); |
|
} else { |
|
HandlesClause( |
|
#line 922 "VBNET.ATG" |
|
out handlesClause); |
|
} |
|
} |
|
|
|
#line 925 "VBNET.ATG" |
|
Point endLocation = t.EndLocation; |
|
Expect(1); |
|
if ( |
|
#line 929 "VBNET.ATG" |
|
IsMustOverride(m)) { |
|
|
|
#line 931 "VBNET.ATG" |
|
methodDeclaration = new MethodDeclaration(name, m.Modifier, null, p, attributes); |
|
methodDeclaration.StartLocation = m.GetDeclarationLocation(startPos); |
|
methodDeclaration.EndLocation = endLocation; |
|
methodDeclaration.TypeReference = new TypeReference("", "System.Void"); |
|
|
|
methodDeclaration.Templates = templates; |
|
methodDeclaration.HandlesClause = handlesClause; |
|
methodDeclaration.ImplementsClause = implementsClause; |
|
|
|
compilationUnit.AddChild(methodDeclaration); |
|
|
|
} else if (StartOf(11)) { |
|
|
|
#line 944 "VBNET.ATG" |
|
methodDeclaration = new MethodDeclaration(name, m.Modifier, null, p, attributes); |
|
methodDeclaration.StartLocation = m.GetDeclarationLocation(startPos); |
|
methodDeclaration.EndLocation = endLocation; |
|
methodDeclaration.TypeReference = new TypeReference("", "System.Void"); |
|
|
|
methodDeclaration.Templates = templates; |
|
methodDeclaration.HandlesClause = handlesClause; |
|
methodDeclaration.ImplementsClause = implementsClause; |
|
|
|
compilationUnit.AddChild(methodDeclaration); |
|
compilationUnit.BlockStart(methodDeclaration); |
|
|
|
Block( |
|
#line 956 "VBNET.ATG" |
|
out stmt); |
|
|
|
#line 958 "VBNET.ATG" |
|
compilationUnit.BlockEnd(); |
|
methodDeclaration.Body = (BlockStatement)stmt; |
|
|
|
Expect(87); |
|
Expect(167); |
|
|
|
#line 961 "VBNET.ATG" |
|
methodDeclaration.Body.EndLocation = t.EndLocation; |
|
Expect(1); |
|
} else SynErr(216); |
|
} else if (la.kind == 126) { |
|
lexer.NextToken(); |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(4)) { |
|
FormalParameterList( |
|
#line 964 "VBNET.ATG" |
|
p); |
|
} |
|
Expect(24); |
|
} |
|
|
|
#line 965 "VBNET.ATG" |
|
m.Check(Modifier.Constructors); |
|
|
|
#line 966 "VBNET.ATG" |
|
Point constructorEndLocation = t.EndLocation; |
|
Expect(1); |
|
Block( |
|
#line 968 "VBNET.ATG" |
|
out stmt); |
|
Expect(87); |
|
Expect(167); |
|
|
|
#line 969 "VBNET.ATG" |
|
Point endLocation = t.EndLocation; |
|
Expect(1); |
|
|
|
#line 971 "VBNET.ATG" |
|
ConstructorDeclaration cd = new ConstructorDeclaration("New", m.Modifier, p, attributes); |
|
cd.StartLocation = m.GetDeclarationLocation(startPos); |
|
cd.EndLocation = constructorEndLocation; |
|
cd.Body = (BlockStatement)stmt; |
|
cd.Body.EndLocation = endLocation; |
|
compilationUnit.AddChild(cd); |
|
|
|
} else SynErr(217); |
|
break; |
|
} |
|
case 99: { |
|
lexer.NextToken(); |
|
|
|
#line 983 "VBNET.ATG" |
|
m.Check(Modifier.VBMethods); |
|
string name = String.Empty; |
|
Point startPos = t.Location; |
|
MethodDeclaration methodDeclaration;ArrayList handlesClause = null;ArrayList implementsClause = null; |
|
AttributeSection returnTypeAttributeSection = null; |
|
|
|
Identifier(); |
|
|
|
#line 989 "VBNET.ATG" |
|
name = t.val; |
|
TypeParameterList( |
|
#line 990 "VBNET.ATG" |
|
templates); |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(4)) { |
|
FormalParameterList( |
|
#line 991 "VBNET.ATG" |
|
p); |
|
} |
|
Expect(24); |
|
} |
|
if (la.kind == 47) { |
|
lexer.NextToken(); |
|
while (la.kind == 26) { |
|
AttributeSection( |
|
#line 992 "VBNET.ATG" |
|
out returnTypeAttributeSection); |
|
} |
|
TypeName( |
|
#line 992 "VBNET.ATG" |
|
out type); |
|
} |
|
|
|
#line 994 "VBNET.ATG" |
|
if(type == null) { |
|
type = new TypeReference("System.Object"); |
|
} |
|
|
|
if (la.kind == 104 || la.kind == 106) { |
|
if (la.kind == 106) { |
|
ImplementsClause( |
|
#line 1000 "VBNET.ATG" |
|
out implementsClause); |
|
} else { |
|
HandlesClause( |
|
#line 1002 "VBNET.ATG" |
|
out handlesClause); |
|
} |
|
} |
|
Expect(1); |
|
if ( |
|
#line 1008 "VBNET.ATG" |
|
IsMustOverride(m)) { |
|
|
|
#line 1010 "VBNET.ATG" |
|
methodDeclaration = new MethodDeclaration(name, m.Modifier, type, p, attributes); |
|
methodDeclaration.StartLocation = m.GetDeclarationLocation(startPos); |
|
methodDeclaration.EndLocation = t.EndLocation; |
|
|
|
methodDeclaration.HandlesClause = handlesClause; |
|
methodDeclaration.Templates = templates; |
|
methodDeclaration.ImplementsClause = implementsClause; |
|
methodDeclaration.ReturnTypeAttributeSection = returnTypeAttributeSection; |
|
compilationUnit.AddChild(methodDeclaration); |
|
|
|
} else if (StartOf(11)) { |
|
|
|
#line 1022 "VBNET.ATG" |
|
methodDeclaration = new MethodDeclaration(name, m.Modifier, type, p, attributes); |
|
methodDeclaration.StartLocation = m.GetDeclarationLocation(startPos); |
|
methodDeclaration.EndLocation = t.EndLocation; |
|
|
|
methodDeclaration.Templates = templates; |
|
methodDeclaration.HandlesClause = handlesClause; |
|
methodDeclaration.ImplementsClause = implementsClause; |
|
methodDeclaration.ReturnTypeAttributeSection = returnTypeAttributeSection; |
|
|
|
compilationUnit.AddChild(methodDeclaration); |
|
compilationUnit.BlockStart(methodDeclaration); |
|
|
|
Block( |
|
#line 1034 "VBNET.ATG" |
|
out stmt); |
|
|
|
#line 1036 "VBNET.ATG" |
|
compilationUnit.BlockEnd(); |
|
methodDeclaration.Body = (BlockStatement)stmt; |
|
|
|
Expect(87); |
|
Expect(99); |
|
|
|
#line 1041 "VBNET.ATG" |
|
methodDeclaration.Body.StartLocation = methodDeclaration.EndLocation; |
|
methodDeclaration.Body.EndLocation = t.EndLocation; |
|
|
|
Expect(1); |
|
} else SynErr(218); |
|
break; |
|
} |
|
case 77: { |
|
lexer.NextToken(); |
|
|
|
#line 1050 "VBNET.ATG" |
|
m.Check(Modifier.VBExternalMethods); |
|
Point startPos = t.Location; |
|
CharsetModifier charsetModifer = CharsetModifier.None; |
|
string library = String.Empty; |
|
string alias = null; |
|
string name = String.Empty; |
|
|
|
if (StartOf(12)) { |
|
Charset( |
|
#line 1057 "VBNET.ATG" |
|
out charsetModifer); |
|
} |
|
if (la.kind == 167) { |
|
lexer.NextToken(); |
|
Identifier(); |
|
|
|
#line 1060 "VBNET.ATG" |
|
name = t.val; |
|
Expect(114); |
|
Expect(3); |
|
|
|
#line 1061 "VBNET.ATG" |
|
library = t.val.ToString(); |
|
if (la.kind == 43) { |
|
lexer.NextToken(); |
|
Expect(3); |
|
|
|
#line 1062 "VBNET.ATG" |
|
alias = t.val.ToString(); |
|
} |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(4)) { |
|
FormalParameterList( |
|
#line 1063 "VBNET.ATG" |
|
p); |
|
} |
|
Expect(24); |
|
} |
|
Expect(1); |
|
|
|
#line 1066 "VBNET.ATG" |
|
DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, null, p, attributes, library, alias, charsetModifer); |
|
declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos); |
|
declareDeclaration.EndLocation = t.EndLocation; |
|
compilationUnit.AddChild(declareDeclaration); |
|
|
|
} else if (la.kind == 99) { |
|
lexer.NextToken(); |
|
Identifier(); |
|
|
|
#line 1073 "VBNET.ATG" |
|
name = t.val; |
|
Expect(114); |
|
Expect(3); |
|
|
|
#line 1074 "VBNET.ATG" |
|
library = t.val; |
|
if (la.kind == 43) { |
|
lexer.NextToken(); |
|
Expect(3); |
|
|
|
#line 1075 "VBNET.ATG" |
|
alias = t.val; |
|
} |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(4)) { |
|
FormalParameterList( |
|
#line 1076 "VBNET.ATG" |
|
p); |
|
} |
|
Expect(24); |
|
} |
|
if (la.kind == 47) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 1077 "VBNET.ATG" |
|
out type); |
|
} |
|
Expect(1); |
|
|
|
#line 1080 "VBNET.ATG" |
|
DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, type, p, attributes, library, alias, charsetModifer); |
|
declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos); |
|
declareDeclaration.EndLocation = t.EndLocation; |
|
compilationUnit.AddChild(declareDeclaration); |
|
|
|
} else SynErr(219); |
|
break; |
|
} |
|
case 92: { |
|
lexer.NextToken(); |
|
|
|
#line 1090 "VBNET.ATG" |
|
m.Check(Modifier.VBEvents); |
|
Point startPos = t.Location; |
|
EventDeclaration eventDeclaration; |
|
string name = String.Empty;ArrayList implementsClause = null; |
|
|
|
Identifier(); |
|
|
|
#line 1095 "VBNET.ATG" |
|
name= t.val; |
|
if (la.kind == 47) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 1097 "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 1099 "VBNET.ATG" |
|
p); |
|
} |
|
Expect(24); |
|
} |
|
} else SynErr(220); |
|
if (la.kind == 106) { |
|
ImplementsClause( |
|
#line 1101 "VBNET.ATG" |
|
out implementsClause); |
|
} |
|
|
|
#line 1103 "VBNET.ATG" |
|
eventDeclaration = new EventDeclaration(type, m.Modifier, p, attributes, name, implementsClause); |
|
eventDeclaration.StartLocation = m.GetDeclarationLocation(startPos); |
|
eventDeclaration.EndLocation = t.EndLocation; |
|
compilationUnit.AddChild(eventDeclaration); |
|
|
|
Expect(1); |
|
break; |
|
} |
|
case 2: case 50: case 69: case 169: { |
|
|
|
#line 1110 "VBNET.ATG" |
|
Point startPos = t.Location; |
|
|
|
#line 1112 "VBNET.ATG" |
|
m.Check(Modifier.Fields); |
|
FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier); |
|
fd.StartLocation = m.GetDeclarationLocation(startPos); |
|
|
|
VariableDeclarator( |
|
#line 1116 "VBNET.ATG" |
|
variableDeclarators); |
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
VariableDeclarator( |
|
#line 1117 "VBNET.ATG" |
|
variableDeclarators); |
|
} |
|
Expect(1); |
|
|
|
#line 1120 "VBNET.ATG" |
|
fd.EndLocation = t.EndLocation; |
|
fd.Fields = variableDeclarators; |
|
compilationUnit.AddChild(fd); |
|
|
|
break; |
|
} |
|
case 70: { |
|
|
|
#line 1125 "VBNET.ATG" |
|
m.Check(Modifier.Fields); |
|
lexer.NextToken(); |
|
|
|
#line 1126 "VBNET.ATG" |
|
m.Add(Modifier.Const, t.Location); |
|
|
|
#line 1128 "VBNET.ATG" |
|
FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier); |
|
fd.StartLocation = m.GetDeclarationLocation(t.Location); |
|
List<VariableDeclaration> constantDeclarators = new List<VariableDeclaration>(); |
|
|
|
ConstantDeclarator( |
|
#line 1132 "VBNET.ATG" |
|
constantDeclarators); |
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
ConstantDeclarator( |
|
#line 1133 "VBNET.ATG" |
|
constantDeclarators); |
|
} |
|
|
|
#line 1135 "VBNET.ATG" |
|
fd.Fields = constantDeclarators; |
|
fd.EndLocation = t.Location; |
|
|
|
Expect(1); |
|
|
|
#line 1140 "VBNET.ATG" |
|
fd.EndLocation = t.EndLocation; |
|
compilationUnit.AddChild(fd); |
|
|
|
break; |
|
} |
|
case 146: { |
|
lexer.NextToken(); |
|
|
|
#line 1146 "VBNET.ATG" |
|
m.Check(Modifier.VBProperties); |
|
Point startPos = t.Location; |
|
ArrayList implementsClause = null; |
|
|
|
Identifier(); |
|
|
|
#line 1150 "VBNET.ATG" |
|
string propertyName = t.val; |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(4)) { |
|
FormalParameterList( |
|
#line 1151 "VBNET.ATG" |
|
p); |
|
} |
|
Expect(24); |
|
} |
|
if (la.kind == 47) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 1152 "VBNET.ATG" |
|
out type); |
|
} |
|
|
|
#line 1154 "VBNET.ATG" |
|
if(type == null) { |
|
type = new TypeReference("System.Object"); |
|
} |
|
|
|
if (la.kind == 106) { |
|
ImplementsClause( |
|
#line 1158 "VBNET.ATG" |
|
out implementsClause); |
|
} |
|
Expect(1); |
|
if ( |
|
#line 1162 "VBNET.ATG" |
|
IsMustOverride(m)) { |
|
|
|
#line 1164 "VBNET.ATG" |
|
PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes); |
|
pDecl.StartLocation = m.GetDeclarationLocation(startPos); |
|
pDecl.EndLocation = t.Location; |
|
pDecl.TypeReference = type; |
|
pDecl.ImplementsClause = implementsClause; |
|
pDecl.Parameters = p; |
|
compilationUnit.AddChild(pDecl); |
|
|
|
} else if (la.kind == 26 || la.kind == 100 || la.kind == 156) { |
|
|
|
#line 1174 "VBNET.ATG" |
|
PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes); |
|
pDecl.StartLocation = m.GetDeclarationLocation(startPos); |
|
pDecl.EndLocation = t.Location; |
|
pDecl.BodyStart = t.Location; |
|
pDecl.TypeReference = type; |
|
pDecl.ImplementsClause = implementsClause; |
|
pDecl.Parameters = p; |
|
PropertyGetRegion getRegion; |
|
PropertySetRegion setRegion; |
|
|
|
AccessorDecls( |
|
#line 1184 "VBNET.ATG" |
|
out getRegion, out setRegion); |
|
Expect(87); |
|
Expect(146); |
|
Expect(1); |
|
|
|
#line 1188 "VBNET.ATG" |
|
pDecl.GetRegion = getRegion; |
|
pDecl.SetRegion = setRegion; |
|
pDecl.BodyEnd = t.EndLocation; |
|
compilationUnit.AddChild(pDecl); |
|
|
|
} else SynErr(221); |
|
break; |
|
} |
|
case 200: { |
|
lexer.NextToken(); |
|
|
|
#line 1195 "VBNET.ATG" |
|
Point startPos = t.Location; |
|
Expect(92); |
|
|
|
#line 1197 "VBNET.ATG" |
|
m.Check(Modifier.VBCustomEvents); |
|
EventAddRemoveRegion eventAccessorDeclaration; |
|
EventAddRemoveRegion addHandlerAccessorDeclaration = null; |
|
EventAddRemoveRegion removeHandlerAccessorDeclaration = null; |
|
EventAddRemoveRegion raiseEventAccessorDeclaration = null; |
|
ArrayList implementsClause = null; |
|
|
|
Identifier(); |
|
|
|
#line 1204 "VBNET.ATG" |
|
string customEventName = t.val; |
|
Expect(47); |
|
TypeName( |
|
#line 1205 "VBNET.ATG" |
|
out type); |
|
if (la.kind == 106) { |
|
ImplementsClause( |
|
#line 1206 "VBNET.ATG" |
|
out implementsClause); |
|
} |
|
Expect(1); |
|
while (StartOf(13)) { |
|
EventAccessorDeclaration( |
|
#line 1209 "VBNET.ATG" |
|
out eventAccessorDeclaration); |
|
|
|
#line 1211 "VBNET.ATG" |
|
if(eventAccessorDeclaration is EventAddRegion) |
|
{ |
|
addHandlerAccessorDeclaration = eventAccessorDeclaration; |
|
} |
|
else if(eventAccessorDeclaration is EventRemoveRegion) |
|
{ |
|
removeHandlerAccessorDeclaration = eventAccessorDeclaration; |
|
} |
|
else if(eventAccessorDeclaration is EventRaiseRegion) |
|
{ |
|
raiseEventAccessorDeclaration = eventAccessorDeclaration; |
|
} |
|
|
|
} |
|
Expect(87); |
|
Expect(92); |
|
Expect(1); |
|
|
|
#line 1227 "VBNET.ATG" |
|
if(addHandlerAccessorDeclaration == null) |
|
{ |
|
Error("Need to provide AddHandler accessor."); |
|
} |
|
|
|
if(addHandlerAccessorDeclaration == null) |
|
{ |
|
Error("Need to provide RemoveHandler accessor."); |
|
} |
|
|
|
if(addHandlerAccessorDeclaration == null) |
|
{ |
|
Error("Need to provide RaiseEvent accessor."); |
|
} |
|
|
|
EventDeclaration decl = new EventDeclaration(type, customEventName, m.Modifier, attributes); |
|
decl.StartLocation = m.GetDeclarationLocation(startPos); |
|
decl.EndLocation = t.EndLocation; |
|
compilationUnit.AddChild(decl); |
|
|
|
break; |
|
} |
|
case 187: { |
|
lexer.NextToken(); |
|
|
|
#line 1250 "VBNET.ATG" |
|
m.Check(Modifier.VBOperators); |
|
Point startPos = t.Location; |
|
TypeReference returnType = NullTypeReference.Instance; |
|
TypeReference operandType = NullTypeReference.Instance; |
|
string operandName; |
|
OverloadableOperatorType operatorType; |
|
AttributeSection section; |
|
List<ParameterDeclarationExpression> parameters = new List<ParameterDeclarationExpression>(); |
|
List<AttributeSection> returnTypeAttributes = new List<AttributeSection>(); |
|
|
|
OverloadableOperator( |
|
#line 1260 "VBNET.ATG" |
|
out operatorType); |
|
Expect(23); |
|
if (la.kind == 54) { |
|
lexer.NextToken(); |
|
} |
|
Identifier(); |
|
|
|
#line 1261 "VBNET.ATG" |
|
operandName = t.val; |
|
if (la.kind == 47) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 1262 "VBNET.ATG" |
|
out operandType); |
|
} |
|
|
|
#line 1263 "VBNET.ATG" |
|
parameters.Add(new ParameterDeclarationExpression(operandType, operandName, ParamModifier.In)); |
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
if (la.kind == 54) { |
|
lexer.NextToken(); |
|
} |
|
Identifier(); |
|
|
|
#line 1267 "VBNET.ATG" |
|
operandName = t.val; |
|
if (la.kind == 47) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 1268 "VBNET.ATG" |
|
out operandType); |
|
} |
|
|
|
#line 1269 "VBNET.ATG" |
|
parameters.Add(new ParameterDeclarationExpression(operandType, operandName, ParamModifier.In)); |
|
} |
|
Expect(24); |
|
|
|
#line 1272 "VBNET.ATG" |
|
Point endPos = t.EndLocation; |
|
if (la.kind == 47) { |
|
lexer.NextToken(); |
|
while (la.kind == 26) { |
|
AttributeSection( |
|
#line 1273 "VBNET.ATG" |
|
out section); |
|
|
|
#line 1273 "VBNET.ATG" |
|
returnTypeAttributes.Add(section); |
|
} |
|
TypeName( |
|
#line 1273 "VBNET.ATG" |
|
out returnType); |
|
|
|
#line 1273 "VBNET.ATG" |
|
endPos = t.EndLocation; |
|
Expect(1); |
|
} |
|
Block( |
|
#line 1274 "VBNET.ATG" |
|
out stmt); |
|
Expect(87); |
|
Expect(187); |
|
Expect(1); |
|
|
|
#line 1276 "VBNET.ATG" |
|
OperatorDeclaration operatorDeclaration = new OperatorDeclaration(m.Modifier, |
|
attributes, |
|
parameters, |
|
returnType, |
|
operatorType |
|
); |
|
operatorDeclaration.ConvertToType = returnType; |
|
operatorDeclaration.ReturnTypeAttributes = returnTypeAttributes; |
|
operatorDeclaration.Body = (BlockStatement)stmt; |
|
operatorDeclaration.StartLocation = m.GetDeclarationLocation(startPos); |
|
operatorDeclaration.EndLocation = endPos; |
|
operatorDeclaration.Body.StartLocation = startPos; |
|
operatorDeclaration.Body.EndLocation = t.Location; |
|
compilationUnit.AddChild(operatorDeclaration); |
|
|
|
break; |
|
} |
|
default: SynErr(222); break; |
|
} |
|
} |
|
|
|
void EnumMemberDecl( |
|
#line 860 "VBNET.ATG" |
|
out FieldDeclaration f) { |
|
|
|
#line 862 "VBNET.ATG" |
|
Expression expr = null;List<AttributeSection> attributes = new List<AttributeSection>(); |
|
AttributeSection section = null; |
|
VariableDeclaration varDecl = null; |
|
|
|
while (la.kind == 26) { |
|
AttributeSection( |
|
#line 866 "VBNET.ATG" |
|
out section); |
|
|
|
#line 866 "VBNET.ATG" |
|
attributes.Add(section); |
|
} |
|
Identifier(); |
|
|
|
#line 869 "VBNET.ATG" |
|
f = new FieldDeclaration(attributes); |
|
varDecl = new VariableDeclaration(t.val); |
|
f.Fields.Add(varDecl); |
|
f.StartLocation = t.Location; |
|
|
|
if (la.kind == 11) { |
|
lexer.NextToken(); |
|
Expr( |
|
#line 874 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 874 "VBNET.ATG" |
|
varDecl.Initializer = expr; |
|
} |
|
Expect(1); |
|
} |
|
|
|
void InterfaceMemberDecl() { |
|
|
|
#line 779 "VBNET.ATG" |
|
TypeReference type =null; |
|
List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>(); |
|
List<TemplateDefinition> templates = new List<TemplateDefinition>(); |
|
AttributeSection section, returnTypeAttributeSection = null; |
|
Modifiers mod = new Modifiers(); |
|
List<AttributeSection> attributes = new List<AttributeSection>(); |
|
string name; |
|
|
|
if (StartOf(14)) { |
|
while (la.kind == 26) { |
|
AttributeSection( |
|
#line 787 "VBNET.ATG" |
|
out section); |
|
|
|
#line 787 "VBNET.ATG" |
|
attributes.Add(section); |
|
} |
|
while (StartOf(7)) { |
|
MemberModifier( |
|
#line 791 "VBNET.ATG" |
|
mod); |
|
} |
|
if (la.kind == 92) { |
|
lexer.NextToken(); |
|
|
|
#line 794 "VBNET.ATG" |
|
mod.Check(Modifier.VBInterfaceEvents); |
|
Identifier(); |
|
|
|
#line 795 "VBNET.ATG" |
|
name = t.val; |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(4)) { |
|
FormalParameterList( |
|
#line 796 "VBNET.ATG" |
|
p); |
|
} |
|
Expect(24); |
|
} |
|
if (la.kind == 47) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 797 "VBNET.ATG" |
|
out type); |
|
} |
|
Expect(1); |
|
|
|
#line 800 "VBNET.ATG" |
|
EventDeclaration ed = new EventDeclaration(type, mod.Modifier, p, attributes, name, null); |
|
compilationUnit.AddChild(ed); |
|
ed.EndLocation = t.EndLocation; |
|
|
|
} else if (la.kind == 167) { |
|
lexer.NextToken(); |
|
|
|
#line 806 "VBNET.ATG" |
|
mod.Check(Modifier.VBInterfaceMethods); |
|
Identifier(); |
|
|
|
#line 807 "VBNET.ATG" |
|
name = t.val; |
|
TypeParameterList( |
|
#line 808 "VBNET.ATG" |
|
templates); |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(4)) { |
|
FormalParameterList( |
|
#line 809 "VBNET.ATG" |
|
p); |
|
} |
|
Expect(24); |
|
} |
|
Expect(1); |
|
|
|
#line 812 "VBNET.ATG" |
|
MethodDeclaration md = new MethodDeclaration(name, mod.Modifier, null, p, attributes); |
|
md.TypeReference = new TypeReference("", "System.Void"); |
|
md.EndLocation = t.EndLocation; |
|
md.Templates = templates; |
|
compilationUnit.AddChild(md); |
|
|
|
} else if (la.kind == 99) { |
|
lexer.NextToken(); |
|
|
|
#line 820 "VBNET.ATG" |
|
mod.Check(Modifier.VBInterfaceMethods); |
|
Identifier(); |
|
|
|
#line 821 "VBNET.ATG" |
|
name = t.val; |
|
TypeParameterList( |
|
#line 822 "VBNET.ATG" |
|
templates); |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(4)) { |
|
FormalParameterList( |
|
#line 823 "VBNET.ATG" |
|
p); |
|
} |
|
Expect(24); |
|
} |
|
if (la.kind == 47) { |
|
lexer.NextToken(); |
|
while (la.kind == 26) { |
|
AttributeSection( |
|
#line 824 "VBNET.ATG" |
|
out returnTypeAttributeSection); |
|
} |
|
TypeName( |
|
#line 824 "VBNET.ATG" |
|
out type); |
|
} |
|
|
|
#line 826 "VBNET.ATG" |
|
if(type == null) { |
|
type = new TypeReference("System.Object"); |
|
} |
|
MethodDeclaration md = new MethodDeclaration(name, mod.Modifier, type, p, attributes); |
|
md.ReturnTypeAttributeSection = returnTypeAttributeSection; |
|
md.EndLocation = t.EndLocation; |
|
md.Templates = templates; |
|
compilationUnit.AddChild(md); |
|
|
|
Expect(1); |
|
} else if (la.kind == 146) { |
|
lexer.NextToken(); |
|
|
|
#line 838 "VBNET.ATG" |
|
mod.Check(Modifier.VBInterfaceProperties); |
|
Identifier(); |
|
|
|
#line 839 "VBNET.ATG" |
|
name = t.val; |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(4)) { |
|
FormalParameterList( |
|
#line 840 "VBNET.ATG" |
|
p); |
|
} |
|
Expect(24); |
|
} |
|
if (la.kind == 47) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 841 "VBNET.ATG" |
|
out type); |
|
} |
|
|
|
#line 843 "VBNET.ATG" |
|
if(type == null) { |
|
type = new TypeReference("System.Object"); |
|
} |
|
|
|
Expect(1); |
|
|
|
#line 849 "VBNET.ATG" |
|
PropertyDeclaration pd = new PropertyDeclaration(name, type, mod.Modifier, attributes); |
|
pd.Parameters = p; |
|
pd.EndLocation = t.EndLocation; |
|
compilationUnit.AddChild(pd); |
|
|
|
} else SynErr(223); |
|
} else if (StartOf(15)) { |
|
NonModuleDeclaration( |
|
#line 856 "VBNET.ATG" |
|
mod, attributes); |
|
} else SynErr(224); |
|
} |
|
|
|
void Expr( |
|
#line 1620 "VBNET.ATG" |
|
out Expression expr) { |
|
ConditionalOrExpr( |
|
#line 1622 "VBNET.ATG" |
|
out expr); |
|
} |
|
|
|
void ImplementsClause( |
|
#line 1598 "VBNET.ATG" |
|
out ArrayList baseInterfaces) { |
|
|
|
#line 1600 "VBNET.ATG" |
|
baseInterfaces = new ArrayList(); |
|
string typename = String.Empty; |
|
string first; |
|
|
|
Expect(106); |
|
Identifier(); |
|
|
|
#line 1604 "VBNET.ATG" |
|
first = t.val; |
|
Expect(10); |
|
Qualident( |
|
#line 1604 "VBNET.ATG" |
|
out typename); |
|
|
|
#line 1604 "VBNET.ATG" |
|
baseInterfaces.Add(first + "." + typename); |
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
Identifier(); |
|
|
|
#line 1605 "VBNET.ATG" |
|
first = t.val; |
|
Expect(10); |
|
Qualident( |
|
#line 1605 "VBNET.ATG" |
|
out typename); |
|
|
|
#line 1605 "VBNET.ATG" |
|
baseInterfaces.Add(first + "." + typename); |
|
} |
|
} |
|
|
|
void HandlesClause( |
|
#line 1556 "VBNET.ATG" |
|
out ArrayList handlesClause) { |
|
|
|
#line 1558 "VBNET.ATG" |
|
handlesClause = new ArrayList(); |
|
string name; |
|
|
|
Expect(104); |
|
EventMemberSpecifier( |
|
#line 1561 "VBNET.ATG" |
|
out name); |
|
|
|
#line 1561 "VBNET.ATG" |
|
handlesClause.Add(name); |
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
EventMemberSpecifier( |
|
#line 1562 "VBNET.ATG" |
|
out name); |
|
|
|
#line 1562 "VBNET.ATG" |
|
handlesClause.Add(name); |
|
} |
|
} |
|
|
|
void Block( |
|
#line 2168 "VBNET.ATG" |
|
out Statement stmt) { |
|
|
|
#line 2171 "VBNET.ATG" |
|
BlockStatement blockStmt = new BlockStatement(); |
|
blockStmt.StartLocation = t.Location; |
|
compilationUnit.BlockStart(blockStmt); |
|
|
|
while (StartOf(16) || |
|
#line 2176 "VBNET.ATG" |
|
IsEndStmtAhead()) { |
|
if ( |
|
#line 2176 "VBNET.ATG" |
|
IsEndStmtAhead()) { |
|
Expect(87); |
|
EndOfStmt(); |
|
|
|
#line 2176 "VBNET.ATG" |
|
compilationUnit.AddChild(new EndStatement()); |
|
} else { |
|
Statement(); |
|
EndOfStmt(); |
|
} |
|
} |
|
|
|
#line 2182 "VBNET.ATG" |
|
stmt = blockStmt; |
|
blockStmt.EndLocation = t.EndLocation; |
|
compilationUnit.BlockEnd(); |
|
|
|
} |
|
|
|
void Charset( |
|
#line 1548 "VBNET.ATG" |
|
out CharsetModifier charsetModifier) { |
|
|
|
#line 1549 "VBNET.ATG" |
|
charsetModifier = CharsetModifier.None; |
|
if (la.kind == 99 || la.kind == 167) { |
|
} else if (la.kind == 46) { |
|
lexer.NextToken(); |
|
|
|
#line 1550 "VBNET.ATG" |
|
charsetModifier = CharsetModifier.ANSI; |
|
} else if (la.kind == 49) { |
|
lexer.NextToken(); |
|
|
|
#line 1551 "VBNET.ATG" |
|
charsetModifier = CharsetModifier.Auto; |
|
} else if (la.kind == 176) { |
|
lexer.NextToken(); |
|
|
|
#line 1552 "VBNET.ATG" |
|
charsetModifier = CharsetModifier.Unicode; |
|
} else SynErr(225); |
|
} |
|
|
|
void VariableDeclarator( |
|
#line 1466 "VBNET.ATG" |
|
List<VariableDeclaration> fieldDeclaration) { |
|
|
|
#line 1468 "VBNET.ATG" |
|
Expression expr = null; |
|
TypeReference type = null;ArrayList rank = null;ArrayList dimension = null; |
|
|
|
Identifier(); |
|
|
|
#line 1471 "VBNET.ATG" |
|
string name = t.val; |
|
if ( |
|
#line 1472 "VBNET.ATG" |
|
IsDims()) { |
|
ArrayNameModifier( |
|
#line 1472 "VBNET.ATG" |
|
out rank); |
|
} |
|
if ( |
|
#line 1473 "VBNET.ATG" |
|
IsSize()) { |
|
ArrayInitializationModifier( |
|
#line 1473 "VBNET.ATG" |
|
out dimension); |
|
} |
|
if ( |
|
#line 1475 "VBNET.ATG" |
|
IsObjectCreation()) { |
|
Expect(47); |
|
ObjectCreateExpression( |
|
#line 1475 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1477 "VBNET.ATG" |
|
if (expr is ObjectCreateExpression) { |
|
type = ((ObjectCreateExpression)expr).CreateType; |
|
} else { |
|
type = ((ArrayCreateExpression)expr).CreateType; |
|
} |
|
|
|
} else if (StartOf(17)) { |
|
if (la.kind == 47) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 1484 "VBNET.ATG" |
|
out type); |
|
} |
|
|
|
#line 1486 "VBNET.ATG" |
|
if (type != null && rank != null) { |
|
if(type.RankSpecifier != null) { |
|
Error("array rank only allowed one time"); |
|
} else { |
|
type.RankSpecifier = (int[])rank.ToArray(typeof(int)); |
|
} |
|
} |
|
|
|
if (la.kind == 11) { |
|
lexer.NextToken(); |
|
VariableInitializer( |
|
#line 1494 "VBNET.ATG" |
|
out expr); |
|
} |
|
} else SynErr(226); |
|
|
|
#line 1496 "VBNET.ATG" |
|
fieldDeclaration.Add(new VariableDeclaration(name, expr, type)); |
|
} |
|
|
|
void ConstantDeclarator( |
|
#line 1449 "VBNET.ATG" |
|
List<VariableDeclaration> constantDeclaration) { |
|
|
|
#line 1451 "VBNET.ATG" |
|
Expression expr = null; |
|
TypeReference type = null; |
|
string name = String.Empty; |
|
|
|
Identifier(); |
|
|
|
#line 1455 "VBNET.ATG" |
|
name = t.val; |
|
if (la.kind == 47) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 1456 "VBNET.ATG" |
|
out type); |
|
} |
|
Expect(11); |
|
Expr( |
|
#line 1457 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1459 "VBNET.ATG" |
|
VariableDeclaration f = new VariableDeclaration(name, expr); |
|
f.TypeReference = type; |
|
constantDeclaration.Add(f); |
|
|
|
} |
|
|
|
void AccessorDecls( |
|
#line 1393 "VBNET.ATG" |
|
out PropertyGetRegion getBlock, out PropertySetRegion setBlock) { |
|
|
|
#line 1395 "VBNET.ATG" |
|
List<AttributeSection> attributes = new List<AttributeSection>(); |
|
AttributeSection section; |
|
getBlock = null; |
|
setBlock = null; |
|
|
|
while (la.kind == 26) { |
|
AttributeSection( |
|
#line 1400 "VBNET.ATG" |
|
out section); |
|
|
|
#line 1400 "VBNET.ATG" |
|
attributes.Add(section); |
|
} |
|
if (la.kind == 100) { |
|
GetAccessorDecl( |
|
#line 1402 "VBNET.ATG" |
|
out getBlock, attributes); |
|
if (la.kind == 26 || la.kind == 156) { |
|
|
|
#line 1404 "VBNET.ATG" |
|
attributes = new List<AttributeSection>(); |
|
while (la.kind == 26) { |
|
AttributeSection( |
|
#line 1405 "VBNET.ATG" |
|
out section); |
|
|
|
#line 1405 "VBNET.ATG" |
|
attributes.Add(section); |
|
} |
|
SetAccessorDecl( |
|
#line 1406 "VBNET.ATG" |
|
out setBlock, attributes); |
|
} |
|
} else if (la.kind == 156) { |
|
SetAccessorDecl( |
|
#line 1409 "VBNET.ATG" |
|
out setBlock, attributes); |
|
if (la.kind == 26 || la.kind == 100) { |
|
|
|
#line 1411 "VBNET.ATG" |
|
attributes = new List<AttributeSection>(); |
|
while (la.kind == 26) { |
|
AttributeSection( |
|
#line 1412 "VBNET.ATG" |
|
out section); |
|
|
|
#line 1412 "VBNET.ATG" |
|
attributes.Add(section); |
|
} |
|
GetAccessorDecl( |
|
#line 1413 "VBNET.ATG" |
|
out getBlock, attributes); |
|
} |
|
} else SynErr(227); |
|
} |
|
|
|
void EventAccessorDeclaration( |
|
#line 1356 "VBNET.ATG" |
|
out EventAddRemoveRegion eventAccessorDeclaration) { |
|
|
|
#line 1358 "VBNET.ATG" |
|
Statement stmt = null; |
|
List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>(); |
|
AttributeSection section; |
|
List<AttributeSection> attributes = new List<AttributeSection>(); |
|
eventAccessorDeclaration = null; |
|
|
|
while (la.kind == 26) { |
|
AttributeSection( |
|
#line 1364 "VBNET.ATG" |
|
out section); |
|
|
|
#line 1364 "VBNET.ATG" |
|
attributes.Add(section); |
|
} |
|
if (la.kind == 41) { |
|
lexer.NextToken(); |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(4)) { |
|
FormalParameterList( |
|
#line 1366 "VBNET.ATG" |
|
p); |
|
} |
|
Expect(24); |
|
} |
|
Expect(1); |
|
Block( |
|
#line 1367 "VBNET.ATG" |
|
out stmt); |
|
Expect(87); |
|
Expect(41); |
|
Expect(1); |
|
|
|
#line 1369 "VBNET.ATG" |
|
eventAccessorDeclaration = new EventAddRegion(attributes); |
|
eventAccessorDeclaration.Block = (BlockStatement)stmt; |
|
eventAccessorDeclaration.Parameters = p; |
|
|
|
} else if (la.kind == 152) { |
|
lexer.NextToken(); |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(4)) { |
|
FormalParameterList( |
|
#line 1374 "VBNET.ATG" |
|
p); |
|
} |
|
Expect(24); |
|
} |
|
Expect(1); |
|
Block( |
|
#line 1375 "VBNET.ATG" |
|
out stmt); |
|
Expect(87); |
|
Expect(152); |
|
Expect(1); |
|
|
|
#line 1377 "VBNET.ATG" |
|
eventAccessorDeclaration = new EventRemoveRegion(attributes); |
|
eventAccessorDeclaration.Block = (BlockStatement)stmt; |
|
eventAccessorDeclaration.Parameters = p; |
|
|
|
} else if (la.kind == 149) { |
|
lexer.NextToken(); |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(4)) { |
|
FormalParameterList( |
|
#line 1382 "VBNET.ATG" |
|
p); |
|
} |
|
Expect(24); |
|
} |
|
Expect(1); |
|
Block( |
|
#line 1383 "VBNET.ATG" |
|
out stmt); |
|
Expect(87); |
|
Expect(149); |
|
Expect(1); |
|
|
|
#line 1385 "VBNET.ATG" |
|
eventAccessorDeclaration = new EventRaiseRegion(attributes); |
|
eventAccessorDeclaration.Block = (BlockStatement)stmt; |
|
eventAccessorDeclaration.Parameters = p; |
|
|
|
} else SynErr(228); |
|
} |
|
|
|
void OverloadableOperator( |
|
#line 1293 "VBNET.ATG" |
|
out OverloadableOperatorType operatorType) { |
|
|
|
#line 1294 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.None; |
|
switch (la.kind) { |
|
case 14: { |
|
lexer.NextToken(); |
|
|
|
#line 1296 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.Add; |
|
break; |
|
} |
|
case 15: { |
|
lexer.NextToken(); |
|
|
|
#line 1298 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.Subtract; |
|
break; |
|
} |
|
case 16: { |
|
lexer.NextToken(); |
|
|
|
#line 1300 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.Multiply; |
|
break; |
|
} |
|
case 17: { |
|
lexer.NextToken(); |
|
|
|
#line 1302 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.Divide; |
|
break; |
|
} |
|
case 18: { |
|
lexer.NextToken(); |
|
|
|
#line 1304 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.DivideInteger; |
|
break; |
|
} |
|
case 19: { |
|
lexer.NextToken(); |
|
|
|
#line 1306 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.Concat; |
|
break; |
|
} |
|
case 115: { |
|
lexer.NextToken(); |
|
|
|
#line 1308 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.Like; |
|
break; |
|
} |
|
case 119: { |
|
lexer.NextToken(); |
|
|
|
#line 1310 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.Modulus; |
|
break; |
|
} |
|
case 44: { |
|
lexer.NextToken(); |
|
|
|
#line 1312 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.BitwiseAnd; |
|
break; |
|
} |
|
case 137: { |
|
lexer.NextToken(); |
|
|
|
#line 1314 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.BitwiseOr; |
|
break; |
|
} |
|
case 185: { |
|
lexer.NextToken(); |
|
|
|
#line 1316 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.ExclusiveOr; |
|
break; |
|
} |
|
case 20: { |
|
lexer.NextToken(); |
|
|
|
#line 1318 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.Power; |
|
break; |
|
} |
|
case 30: { |
|
lexer.NextToken(); |
|
|
|
#line 1320 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.ShiftLeft; |
|
break; |
|
} |
|
case 31: { |
|
lexer.NextToken(); |
|
|
|
#line 1322 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.ShiftRight; |
|
break; |
|
} |
|
case 11: { |
|
lexer.NextToken(); |
|
|
|
#line 1324 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.Equality; |
|
break; |
|
} |
|
case 27: { |
|
lexer.NextToken(); |
|
|
|
#line 1326 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.InEquality; |
|
break; |
|
} |
|
case 26: { |
|
lexer.NextToken(); |
|
|
|
#line 1328 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.LessThan; |
|
break; |
|
} |
|
case 29: { |
|
lexer.NextToken(); |
|
|
|
#line 1330 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.LessThanOrEqual; |
|
break; |
|
} |
|
case 25: { |
|
lexer.NextToken(); |
|
|
|
#line 1332 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.GreaterThan; |
|
break; |
|
} |
|
case 28: { |
|
lexer.NextToken(); |
|
|
|
#line 1334 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.GreaterThanOrEqual; |
|
break; |
|
} |
|
case 74: { |
|
lexer.NextToken(); |
|
|
|
#line 1336 "VBNET.ATG" |
|
operatorType = OverloadableOperatorType.CType; |
|
break; |
|
} |
|
case 2: case 50: case 69: case 169: { |
|
Identifier(); |
|
|
|
#line 1340 "VBNET.ATG" |
|
string opName = t.val; |
|
switch(opName.ToLower()) |
|
{ |
|
case "istrue": |
|
operatorType = OverloadableOperatorType.IsTrue; |
|
break; |
|
case "isfalse": |
|
operatorType = OverloadableOperatorType.IsFalse; |
|
break; |
|
default: |
|
Error("Invalid operator. Possible operators are '+', '-', 'Not', 'IsTrue', 'IsFalse'."); |
|
break; |
|
} |
|
|
|
break; |
|
} |
|
default: SynErr(229); break; |
|
} |
|
} |
|
|
|
void GetAccessorDecl( |
|
#line 1419 "VBNET.ATG" |
|
out PropertyGetRegion getBlock, List<AttributeSection> attributes) { |
|
|
|
#line 1420 "VBNET.ATG" |
|
Statement stmt = null; |
|
Expect(100); |
|
Expect(1); |
|
Block( |
|
#line 1423 "VBNET.ATG" |
|
out stmt); |
|
|
|
#line 1425 "VBNET.ATG" |
|
getBlock = new PropertyGetRegion((BlockStatement)stmt, attributes); |
|
|
|
Expect(87); |
|
Expect(100); |
|
Expect(1); |
|
} |
|
|
|
void SetAccessorDecl( |
|
#line 1432 "VBNET.ATG" |
|
out PropertySetRegion setBlock, List<AttributeSection> attributes) { |
|
|
|
#line 1434 "VBNET.ATG" |
|
Statement stmt = null; List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>(); |
|
|
|
Expect(156); |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(4)) { |
|
FormalParameterList( |
|
#line 1437 "VBNET.ATG" |
|
p); |
|
} |
|
Expect(24); |
|
} |
|
Expect(1); |
|
Block( |
|
#line 1439 "VBNET.ATG" |
|
out stmt); |
|
|
|
#line 1441 "VBNET.ATG" |
|
setBlock = new PropertySetRegion((BlockStatement)stmt, attributes); |
|
setBlock.Parameters = p; |
|
|
|
Expect(87); |
|
Expect(156); |
|
Expect(1); |
|
} |
|
|
|
void ArrayNameModifier( |
|
#line 1960 "VBNET.ATG" |
|
out ArrayList arrayModifiers) { |
|
|
|
#line 1962 "VBNET.ATG" |
|
arrayModifiers = null; |
|
|
|
ArrayTypeModifiers( |
|
#line 1964 "VBNET.ATG" |
|
out arrayModifiers); |
|
} |
|
|
|
void ArrayInitializationModifier( |
|
#line 1500 "VBNET.ATG" |
|
out ArrayList arrayModifiers) { |
|
|
|
#line 1502 "VBNET.ATG" |
|
arrayModifiers = null; |
|
|
|
Expect(23); |
|
InitializationRankList( |
|
#line 1504 "VBNET.ATG" |
|
out arrayModifiers); |
|
Expect(24); |
|
} |
|
|
|
void ObjectCreateExpression( |
|
#line 1876 "VBNET.ATG" |
|
out Expression oce) { |
|
|
|
#line 1878 "VBNET.ATG" |
|
TypeReference type = null; |
|
Expression initializer = null; |
|
ArrayList arguments = null; |
|
oce = null; |
|
|
|
Expect(126); |
|
NonArrayTypeName( |
|
#line 1883 "VBNET.ATG" |
|
out type); |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(18)) { |
|
ArgumentList( |
|
#line 1884 "VBNET.ATG" |
|
out arguments); |
|
} |
|
Expect(24); |
|
} |
|
if (la.kind == 21) { |
|
ArrayInitializer( |
|
#line 1885 "VBNET.ATG" |
|
out initializer); |
|
} |
|
|
|
#line 1887 "VBNET.ATG" |
|
if (initializer == null) { |
|
oce = new ObjectCreateExpression(type, arguments); |
|
} else { |
|
ArrayCreateExpression ace = new ArrayCreateExpression(type, initializer as ArrayInitializerExpression); |
|
ace.Parameters = arguments; |
|
oce = ace; |
|
} |
|
|
|
} |
|
|
|
void VariableInitializer( |
|
#line 1520 "VBNET.ATG" |
|
out Expression initializerExpression) { |
|
|
|
#line 1522 "VBNET.ATG" |
|
initializerExpression = null; |
|
|
|
if (StartOf(19)) { |
|
Expr( |
|
#line 1524 "VBNET.ATG" |
|
out initializerExpression); |
|
} else if (la.kind == 21) { |
|
ArrayInitializer( |
|
#line 1525 "VBNET.ATG" |
|
out initializerExpression); |
|
} else SynErr(230); |
|
} |
|
|
|
void InitializationRankList( |
|
#line 1508 "VBNET.ATG" |
|
out ArrayList rank) { |
|
|
|
#line 1510 "VBNET.ATG" |
|
rank = null; |
|
Expression expr = null; |
|
|
|
Expr( |
|
#line 1513 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1513 "VBNET.ATG" |
|
rank = new ArrayList(); if (expr != null) { rank.Add(expr); } |
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
Expr( |
|
#line 1515 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1515 "VBNET.ATG" |
|
if (expr != null) { rank.Add(expr); } |
|
} |
|
} |
|
|
|
void ArrayInitializer( |
|
#line 1529 "VBNET.ATG" |
|
out Expression outExpr) { |
|
|
|
#line 1531 "VBNET.ATG" |
|
Expression expr = null; |
|
ArrayInitializerExpression initializer = new ArrayInitializerExpression(); |
|
|
|
Expect(21); |
|
if (StartOf(20)) { |
|
VariableInitializer( |
|
#line 1536 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1538 "VBNET.ATG" |
|
if (expr != null) { initializer.CreateExpressions.Add(expr); } |
|
|
|
while ( |
|
#line 1541 "VBNET.ATG" |
|
NotFinalComma()) { |
|
Expect(12); |
|
VariableInitializer( |
|
#line 1541 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1542 "VBNET.ATG" |
|
if (expr != null) { initializer.CreateExpressions.Add(expr); } |
|
} |
|
} |
|
Expect(22); |
|
|
|
#line 1545 "VBNET.ATG" |
|
outExpr = initializer; |
|
} |
|
|
|
void EventMemberSpecifier( |
|
#line 1608 "VBNET.ATG" |
|
out string name) { |
|
|
|
#line 1609 "VBNET.ATG" |
|
string type; name = String.Empty; |
|
if (StartOf(10)) { |
|
Identifier(); |
|
|
|
#line 1610 "VBNET.ATG" |
|
type = t.val; |
|
Expect(10); |
|
Identifier(); |
|
|
|
#line 1612 "VBNET.ATG" |
|
name = type + "." + t.val; |
|
} else if (la.kind == 123) { |
|
lexer.NextToken(); |
|
Expect(10); |
|
if (StartOf(10)) { |
|
Identifier(); |
|
|
|
#line 1615 "VBNET.ATG" |
|
name = "MyBase." + t.val; |
|
} else if (la.kind == 91) { |
|
lexer.NextToken(); |
|
|
|
#line 1616 "VBNET.ATG" |
|
name = "MyBase.Error"; |
|
} else SynErr(231); |
|
} else SynErr(232); |
|
} |
|
|
|
void ConditionalOrExpr( |
|
#line 1755 "VBNET.ATG" |
|
out Expression outExpr) { |
|
|
|
#line 1756 "VBNET.ATG" |
|
Expression expr; |
|
ConditionalAndExpr( |
|
#line 1757 "VBNET.ATG" |
|
out outExpr); |
|
while (la.kind == 138) { |
|
lexer.NextToken(); |
|
ConditionalAndExpr( |
|
#line 1757 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1757 "VBNET.ATG" |
|
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.LogicalOr, expr); |
|
} |
|
} |
|
|
|
void UnaryExpr( |
|
#line 1629 "VBNET.ATG" |
|
out Expression uExpr) { |
|
|
|
#line 1631 "VBNET.ATG" |
|
Expression expr; |
|
UnaryOperatorType uop = UnaryOperatorType.None; |
|
bool isUOp = false; |
|
|
|
while (la.kind == 14 || la.kind == 15 || la.kind == 16) { |
|
if (la.kind == 14) { |
|
lexer.NextToken(); |
|
|
|
#line 1635 "VBNET.ATG" |
|
uop = UnaryOperatorType.Plus; isUOp = true; |
|
} else if (la.kind == 15) { |
|
lexer.NextToken(); |
|
|
|
#line 1636 "VBNET.ATG" |
|
uop = UnaryOperatorType.Minus; isUOp = true; |
|
} else { |
|
lexer.NextToken(); |
|
|
|
#line 1638 "VBNET.ATG" |
|
uop = UnaryOperatorType.Star; isUOp = true; |
|
} |
|
} |
|
SimpleExpr( |
|
#line 1640 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1642 "VBNET.ATG" |
|
if (isUOp) { |
|
uExpr = new UnaryOperatorExpression(expr, uop); |
|
} else { |
|
uExpr = expr; |
|
} |
|
|
|
} |
|
|
|
void SimpleExpr( |
|
#line 1665 "VBNET.ATG" |
|
out Expression pexpr) { |
|
|
|
#line 1667 "VBNET.ATG" |
|
Expression expr; |
|
TypeReference type = null; |
|
string name = String.Empty; |
|
pexpr = null; |
|
|
|
if (StartOf(21) || |
|
#line 1696 "VBNET.ATG" |
|
la.kind == Tokens.Global) { |
|
if (la.kind == 3) { |
|
lexer.NextToken(); |
|
|
|
#line 1675 "VBNET.ATG" |
|
pexpr = new PrimitiveExpression(t.literalValue, t.val); |
|
} else if (la.kind == 4) { |
|
lexer.NextToken(); |
|
|
|
#line 1676 "VBNET.ATG" |
|
pexpr = new PrimitiveExpression(t.literalValue, t.val); |
|
} else if (la.kind == 7) { |
|
lexer.NextToken(); |
|
|
|
#line 1677 "VBNET.ATG" |
|
pexpr = new PrimitiveExpression(t.literalValue, t.val); |
|
} else if (la.kind == 6) { |
|
lexer.NextToken(); |
|
|
|
#line 1678 "VBNET.ATG" |
|
pexpr = new PrimitiveExpression(t.literalValue, t.val); |
|
} else if (la.kind == 5) { |
|
lexer.NextToken(); |
|
|
|
#line 1679 "VBNET.ATG" |
|
pexpr = new PrimitiveExpression(t.literalValue, t.val); |
|
} else if (la.kind == 9) { |
|
lexer.NextToken(); |
|
|
|
#line 1680 "VBNET.ATG" |
|
pexpr = new PrimitiveExpression(t.literalValue, t.val); |
|
} else if (la.kind == 8) { |
|
lexer.NextToken(); |
|
|
|
#line 1681 "VBNET.ATG" |
|
pexpr = new PrimitiveExpression(t.literalValue, t.val); |
|
} else if (la.kind == 173) { |
|
lexer.NextToken(); |
|
|
|
#line 1683 "VBNET.ATG" |
|
pexpr = new PrimitiveExpression(true, "true"); |
|
} else if (la.kind == 95) { |
|
lexer.NextToken(); |
|
|
|
#line 1684 "VBNET.ATG" |
|
pexpr = new PrimitiveExpression(false, "false"); |
|
} else if (la.kind == 129) { |
|
lexer.NextToken(); |
|
|
|
#line 1685 "VBNET.ATG" |
|
pexpr = new PrimitiveExpression(null, "null"); |
|
} else if (la.kind == 23) { |
|
lexer.NextToken(); |
|
Expr( |
|
#line 1686 "VBNET.ATG" |
|
out expr); |
|
Expect(24); |
|
|
|
#line 1686 "VBNET.ATG" |
|
pexpr = new ParenthesizedExpression(expr); |
|
} else if (StartOf(10)) { |
|
Identifier(); |
|
|
|
#line 1687 "VBNET.ATG" |
|
pexpr = new IdentifierExpression(t.val); |
|
} else if (StartOf(22)) { |
|
|
|
#line 1688 "VBNET.ATG" |
|
string val = String.Empty; |
|
PrimitiveTypeName( |
|
#line 1688 "VBNET.ATG" |
|
out val); |
|
Expect(10); |
|
|
|
#line 1689 "VBNET.ATG" |
|
t.val = ""; |
|
Identifier(); |
|
|
|
#line 1689 "VBNET.ATG" |
|
pexpr = new FieldReferenceExpression(new TypeReferenceExpression(val), t.val); |
|
} else if (la.kind == 118) { |
|
lexer.NextToken(); |
|
|
|
#line 1690 "VBNET.ATG" |
|
pexpr = new ThisReferenceExpression(); |
|
} else if (la.kind == 123 || la.kind == 124) { |
|
|
|
#line 1691 "VBNET.ATG" |
|
Expression retExpr = null; |
|
if (la.kind == 123) { |
|
lexer.NextToken(); |
|
|
|
#line 1692 "VBNET.ATG" |
|
retExpr = new BaseReferenceExpression(); |
|
} else if (la.kind == 124) { |
|
lexer.NextToken(); |
|
|
|
#line 1693 "VBNET.ATG" |
|
retExpr = new ClassReferenceExpression(); |
|
} else SynErr(233); |
|
Expect(10); |
|
IdentifierOrKeyword( |
|
#line 1695 "VBNET.ATG" |
|
out name); |
|
|
|
#line 1695 "VBNET.ATG" |
|
pexpr = new FieldReferenceExpression(retExpr, name); |
|
} else if ( |
|
#line 1696 "VBNET.ATG" |
|
la.kind == Tokens.Global) { |
|
TypeName( |
|
#line 1696 "VBNET.ATG" |
|
out type); |
|
|
|
#line 1696 "VBNET.ATG" |
|
pexpr = new TypeReferenceExpression(type); |
|
} else if (la.kind == 126) { |
|
ObjectCreateExpression( |
|
#line 1697 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1697 "VBNET.ATG" |
|
pexpr = expr; |
|
} else if (la.kind == 74 || la.kind == 81) { |
|
if (la.kind == 81) { |
|
lexer.NextToken(); |
|
} else if (la.kind == 74) { |
|
lexer.NextToken(); |
|
} else SynErr(234); |
|
Expect(23); |
|
Expr( |
|
#line 1698 "VBNET.ATG" |
|
out expr); |
|
Expect(12); |
|
TypeName( |
|
#line 1698 "VBNET.ATG" |
|
out type); |
|
Expect(24); |
|
|
|
#line 1698 "VBNET.ATG" |
|
pexpr = new CastExpression(type, expr); |
|
} else if (la.kind == 195) { |
|
lexer.NextToken(); |
|
Expect(23); |
|
Expr( |
|
#line 1699 "VBNET.ATG" |
|
out expr); |
|
Expect(12); |
|
TypeName( |
|
#line 1699 "VBNET.ATG" |
|
out type); |
|
Expect(24); |
|
|
|
#line 1699 "VBNET.ATG" |
|
pexpr = new BinaryOperatorExpression(expr, BinaryOperatorType.AsCast, new TypeReferenceExpression(type)); |
|
} else if (StartOf(23)) { |
|
CastTarget( |
|
#line 1700 "VBNET.ATG" |
|
out type); |
|
Expect(23); |
|
Expr( |
|
#line 1700 "VBNET.ATG" |
|
out expr); |
|
Expect(24); |
|
|
|
#line 1700 "VBNET.ATG" |
|
pexpr = new CastExpression(type, expr, true); |
|
} else if (la.kind == 42) { |
|
lexer.NextToken(); |
|
Expr( |
|
#line 1701 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1701 "VBNET.ATG" |
|
pexpr = new AddressOfExpression(expr); |
|
} else if (la.kind == 101) { |
|
lexer.NextToken(); |
|
Expect(23); |
|
TypeName( |
|
#line 1702 "VBNET.ATG" |
|
out type); |
|
Expect(24); |
|
|
|
#line 1702 "VBNET.ATG" |
|
pexpr = new TypeOfExpression(type); |
|
} else { |
|
lexer.NextToken(); |
|
SimpleExpr( |
|
#line 1703 "VBNET.ATG" |
|
out expr); |
|
Expect(112); |
|
TypeName( |
|
#line 1703 "VBNET.ATG" |
|
out type); |
|
|
|
#line 1703 "VBNET.ATG" |
|
pexpr = new TypeOfIsExpression(expr, type); |
|
} |
|
while (la.kind == 10 || la.kind == 23) { |
|
if (la.kind == 10) { |
|
lexer.NextToken(); |
|
IdentifierOrKeyword( |
|
#line 1706 "VBNET.ATG" |
|
out name); |
|
|
|
#line 1706 "VBNET.ATG" |
|
pexpr = new FieldReferenceExpression(pexpr, name); |
|
} else { |
|
lexer.NextToken(); |
|
|
|
#line 1707 "VBNET.ATG" |
|
ArrayList parameters = new ArrayList(); |
|
if (StartOf(24)) { |
|
if (StartOf(19)) { |
|
Argument( |
|
#line 1709 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1709 "VBNET.ATG" |
|
if (expr != null) { parameters.Add(expr); } |
|
} |
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
if (StartOf(19)) { |
|
Argument( |
|
#line 1712 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1712 "VBNET.ATG" |
|
if (expr != null) { parameters.Add(expr); } |
|
} |
|
} |
|
} |
|
Expect(24); |
|
|
|
#line 1715 "VBNET.ATG" |
|
pexpr = new InvocationExpression(pexpr, parameters); |
|
} |
|
} |
|
} else if (la.kind == 10) { |
|
lexer.NextToken(); |
|
IdentifierOrKeyword( |
|
#line 1719 "VBNET.ATG" |
|
out name); |
|
|
|
#line 1719 "VBNET.ATG" |
|
pexpr = new FieldReferenceExpression(pexpr, name); |
|
while (la.kind == 10 || la.kind == 23) { |
|
if (la.kind == 10) { |
|
lexer.NextToken(); |
|
IdentifierOrKeyword( |
|
#line 1721 "VBNET.ATG" |
|
out name); |
|
|
|
#line 1721 "VBNET.ATG" |
|
pexpr = new FieldReferenceExpression(pexpr, name); |
|
} else { |
|
lexer.NextToken(); |
|
|
|
#line 1722 "VBNET.ATG" |
|
ArrayList parameters = new ArrayList(); |
|
if (StartOf(24)) { |
|
|
|
#line 1724 "VBNET.ATG" |
|
expr = null; |
|
if (StartOf(19)) { |
|
Argument( |
|
#line 1724 "VBNET.ATG" |
|
out expr); |
|
} |
|
|
|
#line 1724 "VBNET.ATG" |
|
if (expr != null) { parameters.Add(expr); } |
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
|
|
#line 1726 "VBNET.ATG" |
|
expr = null; |
|
if (StartOf(19)) { |
|
Argument( |
|
#line 1727 "VBNET.ATG" |
|
out expr); |
|
} |
|
|
|
#line 1727 "VBNET.ATG" |
|
if (expr != null) { parameters.Add(expr); } |
|
} |
|
} |
|
Expect(24); |
|
|
|
#line 1730 "VBNET.ATG" |
|
pexpr = new InvocationExpression(pexpr, parameters); |
|
} |
|
} |
|
} else SynErr(235); |
|
} |
|
|
|
void AssignmentOperator( |
|
#line 1650 "VBNET.ATG" |
|
out AssignmentOperatorType op) { |
|
|
|
#line 1651 "VBNET.ATG" |
|
op = AssignmentOperatorType.None; |
|
switch (la.kind) { |
|
case 11: { |
|
lexer.NextToken(); |
|
|
|
#line 1652 "VBNET.ATG" |
|
op = AssignmentOperatorType.Assign; |
|
break; |
|
} |
|
case 40: { |
|
lexer.NextToken(); |
|
|
|
#line 1653 "VBNET.ATG" |
|
op = AssignmentOperatorType.ConcatString; |
|
break; |
|
} |
|
case 32: { |
|
lexer.NextToken(); |
|
|
|
#line 1654 "VBNET.ATG" |
|
op = AssignmentOperatorType.Add; |
|
break; |
|
} |
|
case 34: { |
|
lexer.NextToken(); |
|
|
|
#line 1655 "VBNET.ATG" |
|
op = AssignmentOperatorType.Subtract; |
|
break; |
|
} |
|
case 35: { |
|
lexer.NextToken(); |
|
|
|
#line 1656 "VBNET.ATG" |
|
op = AssignmentOperatorType.Multiply; |
|
break; |
|
} |
|
case 36: { |
|
lexer.NextToken(); |
|
|
|
#line 1657 "VBNET.ATG" |
|
op = AssignmentOperatorType.Divide; |
|
break; |
|
} |
|
case 37: { |
|
lexer.NextToken(); |
|
|
|
#line 1658 "VBNET.ATG" |
|
op = AssignmentOperatorType.DivideInteger; |
|
break; |
|
} |
|
case 33: { |
|
lexer.NextToken(); |
|
|
|
#line 1659 "VBNET.ATG" |
|
op = AssignmentOperatorType.Power; |
|
break; |
|
} |
|
case 38: { |
|
lexer.NextToken(); |
|
|
|
#line 1660 "VBNET.ATG" |
|
op = AssignmentOperatorType.ShiftLeft; |
|
break; |
|
} |
|
case 39: { |
|
lexer.NextToken(); |
|
|
|
#line 1661 "VBNET.ATG" |
|
op = AssignmentOperatorType.ShiftRight; |
|
break; |
|
} |
|
default: SynErr(236); break; |
|
} |
|
} |
|
|
|
void IdentifierOrKeyword( |
|
#line 2753 "VBNET.ATG" |
|
out string name) { |
|
|
|
#line 2755 "VBNET.ATG" |
|
name = String.Empty; |
|
|
|
switch (la.kind) { |
|
case 2: case 50: case 69: case 169: { |
|
Identifier(); |
|
|
|
#line 2758 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 41: { |
|
lexer.NextToken(); |
|
|
|
#line 2759 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 42: { |
|
lexer.NextToken(); |
|
|
|
#line 2760 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 43: { |
|
lexer.NextToken(); |
|
|
|
#line 2761 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 44: { |
|
lexer.NextToken(); |
|
|
|
#line 2762 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 45: { |
|
lexer.NextToken(); |
|
|
|
#line 2763 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 46: { |
|
lexer.NextToken(); |
|
|
|
#line 2764 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 47: { |
|
lexer.NextToken(); |
|
|
|
#line 2765 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 48: { |
|
lexer.NextToken(); |
|
|
|
#line 2766 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 49: { |
|
lexer.NextToken(); |
|
|
|
#line 2767 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 51: { |
|
lexer.NextToken(); |
|
|
|
#line 2768 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 52: { |
|
lexer.NextToken(); |
|
|
|
#line 2769 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 53: { |
|
lexer.NextToken(); |
|
|
|
#line 2770 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 54: { |
|
lexer.NextToken(); |
|
|
|
#line 2771 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 55: { |
|
lexer.NextToken(); |
|
|
|
#line 2772 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 56: { |
|
lexer.NextToken(); |
|
|
|
#line 2773 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 57: { |
|
lexer.NextToken(); |
|
|
|
#line 2774 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 58: { |
|
lexer.NextToken(); |
|
|
|
#line 2775 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 59: { |
|
lexer.NextToken(); |
|
|
|
#line 2776 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 60: { |
|
lexer.NextToken(); |
|
|
|
#line 2777 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 61: { |
|
lexer.NextToken(); |
|
|
|
#line 2778 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 62: { |
|
lexer.NextToken(); |
|
|
|
#line 2779 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 63: { |
|
lexer.NextToken(); |
|
|
|
#line 2780 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 64: { |
|
lexer.NextToken(); |
|
|
|
#line 2781 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 65: { |
|
lexer.NextToken(); |
|
|
|
#line 2782 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 66: { |
|
lexer.NextToken(); |
|
|
|
#line 2783 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 67: { |
|
lexer.NextToken(); |
|
|
|
#line 2784 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 68: { |
|
lexer.NextToken(); |
|
|
|
#line 2785 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 70: { |
|
lexer.NextToken(); |
|
|
|
#line 2786 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 71: { |
|
lexer.NextToken(); |
|
|
|
#line 2787 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 72: { |
|
lexer.NextToken(); |
|
|
|
#line 2788 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 73: { |
|
lexer.NextToken(); |
|
|
|
#line 2789 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 74: { |
|
lexer.NextToken(); |
|
|
|
#line 2790 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 75: { |
|
lexer.NextToken(); |
|
|
|
#line 2791 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 76: { |
|
lexer.NextToken(); |
|
|
|
#line 2792 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 77: { |
|
lexer.NextToken(); |
|
|
|
#line 2793 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 78: { |
|
lexer.NextToken(); |
|
|
|
#line 2794 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 79: { |
|
lexer.NextToken(); |
|
|
|
#line 2795 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 80: { |
|
lexer.NextToken(); |
|
|
|
#line 2796 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 81: { |
|
lexer.NextToken(); |
|
|
|
#line 2797 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 82: { |
|
lexer.NextToken(); |
|
|
|
#line 2798 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 83: { |
|
lexer.NextToken(); |
|
|
|
#line 2799 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 84: { |
|
lexer.NextToken(); |
|
|
|
#line 2800 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 85: { |
|
lexer.NextToken(); |
|
|
|
#line 2801 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 86: { |
|
lexer.NextToken(); |
|
|
|
#line 2802 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 87: { |
|
lexer.NextToken(); |
|
|
|
#line 2803 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 88: { |
|
lexer.NextToken(); |
|
|
|
#line 2804 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 89: { |
|
lexer.NextToken(); |
|
|
|
#line 2805 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 90: { |
|
lexer.NextToken(); |
|
|
|
#line 2806 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 91: { |
|
lexer.NextToken(); |
|
|
|
#line 2807 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 92: { |
|
lexer.NextToken(); |
|
|
|
#line 2808 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 93: { |
|
lexer.NextToken(); |
|
|
|
#line 2809 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 94: { |
|
lexer.NextToken(); |
|
|
|
#line 2810 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 95: { |
|
lexer.NextToken(); |
|
|
|
#line 2811 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 96: { |
|
lexer.NextToken(); |
|
|
|
#line 2812 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 97: { |
|
lexer.NextToken(); |
|
|
|
#line 2813 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 98: { |
|
lexer.NextToken(); |
|
|
|
#line 2814 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 99: { |
|
lexer.NextToken(); |
|
|
|
#line 2815 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 100: { |
|
lexer.NextToken(); |
|
|
|
#line 2816 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 101: { |
|
lexer.NextToken(); |
|
|
|
#line 2817 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 102: { |
|
lexer.NextToken(); |
|
|
|
#line 2818 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 103: { |
|
lexer.NextToken(); |
|
|
|
#line 2819 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 104: { |
|
lexer.NextToken(); |
|
|
|
#line 2820 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 105: { |
|
lexer.NextToken(); |
|
|
|
#line 2821 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 106: { |
|
lexer.NextToken(); |
|
|
|
#line 2822 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 107: { |
|
lexer.NextToken(); |
|
|
|
#line 2823 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 108: { |
|
lexer.NextToken(); |
|
|
|
#line 2824 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 109: { |
|
lexer.NextToken(); |
|
|
|
#line 2825 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 110: { |
|
lexer.NextToken(); |
|
|
|
#line 2826 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 111: { |
|
lexer.NextToken(); |
|
|
|
#line 2827 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 112: { |
|
lexer.NextToken(); |
|
|
|
#line 2828 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 113: { |
|
lexer.NextToken(); |
|
|
|
#line 2829 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 114: { |
|
lexer.NextToken(); |
|
|
|
#line 2830 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 115: { |
|
lexer.NextToken(); |
|
|
|
#line 2831 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 116: { |
|
lexer.NextToken(); |
|
|
|
#line 2832 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 117: { |
|
lexer.NextToken(); |
|
|
|
#line 2833 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 118: { |
|
lexer.NextToken(); |
|
|
|
#line 2834 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 119: { |
|
lexer.NextToken(); |
|
|
|
#line 2835 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 120: { |
|
lexer.NextToken(); |
|
|
|
#line 2836 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 121: { |
|
lexer.NextToken(); |
|
|
|
#line 2837 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 122: { |
|
lexer.NextToken(); |
|
|
|
#line 2838 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 123: { |
|
lexer.NextToken(); |
|
|
|
#line 2839 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 124: { |
|
lexer.NextToken(); |
|
|
|
#line 2840 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 125: { |
|
lexer.NextToken(); |
|
|
|
#line 2841 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 126: { |
|
lexer.NextToken(); |
|
|
|
#line 2842 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 127: { |
|
lexer.NextToken(); |
|
|
|
#line 2843 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 128: { |
|
lexer.NextToken(); |
|
|
|
#line 2844 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 129: { |
|
lexer.NextToken(); |
|
|
|
#line 2845 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 130: { |
|
lexer.NextToken(); |
|
|
|
#line 2846 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 131: { |
|
lexer.NextToken(); |
|
|
|
#line 2847 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 132: { |
|
lexer.NextToken(); |
|
|
|
#line 2848 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 134: { |
|
lexer.NextToken(); |
|
|
|
#line 2849 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 135: { |
|
lexer.NextToken(); |
|
|
|
#line 2850 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 136: { |
|
lexer.NextToken(); |
|
|
|
#line 2851 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 137: { |
|
lexer.NextToken(); |
|
|
|
#line 2852 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 138: { |
|
lexer.NextToken(); |
|
|
|
#line 2853 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 139: { |
|
lexer.NextToken(); |
|
|
|
#line 2854 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 140: { |
|
lexer.NextToken(); |
|
|
|
#line 2855 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 142: { |
|
lexer.NextToken(); |
|
|
|
#line 2856 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 143: { |
|
lexer.NextToken(); |
|
|
|
#line 2857 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 144: { |
|
lexer.NextToken(); |
|
|
|
#line 2858 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 145: { |
|
lexer.NextToken(); |
|
|
|
#line 2859 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 146: { |
|
lexer.NextToken(); |
|
|
|
#line 2860 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 147: { |
|
lexer.NextToken(); |
|
|
|
#line 2861 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 148: { |
|
lexer.NextToken(); |
|
|
|
#line 2862 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 149: { |
|
lexer.NextToken(); |
|
|
|
#line 2863 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 150: { |
|
lexer.NextToken(); |
|
|
|
#line 2864 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 151: { |
|
lexer.NextToken(); |
|
|
|
#line 2865 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 152: { |
|
lexer.NextToken(); |
|
|
|
#line 2866 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 153: { |
|
lexer.NextToken(); |
|
|
|
#line 2867 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 154: { |
|
lexer.NextToken(); |
|
|
|
#line 2868 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 155: { |
|
lexer.NextToken(); |
|
|
|
#line 2869 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 156: { |
|
lexer.NextToken(); |
|
|
|
#line 2870 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 157: { |
|
lexer.NextToken(); |
|
|
|
#line 2871 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 158: { |
|
lexer.NextToken(); |
|
|
|
#line 2872 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 159: { |
|
lexer.NextToken(); |
|
|
|
#line 2873 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 160: { |
|
lexer.NextToken(); |
|
|
|
#line 2874 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 161: { |
|
lexer.NextToken(); |
|
|
|
#line 2875 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 162: { |
|
lexer.NextToken(); |
|
|
|
#line 2876 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 163: { |
|
lexer.NextToken(); |
|
|
|
#line 2877 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 165: { |
|
lexer.NextToken(); |
|
|
|
#line 2878 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 166: { |
|
lexer.NextToken(); |
|
|
|
#line 2879 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 167: { |
|
lexer.NextToken(); |
|
|
|
#line 2880 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 168: { |
|
lexer.NextToken(); |
|
|
|
#line 2881 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 170: { |
|
lexer.NextToken(); |
|
|
|
#line 2882 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 171: { |
|
lexer.NextToken(); |
|
|
|
#line 2883 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 172: { |
|
lexer.NextToken(); |
|
|
|
#line 2884 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 173: { |
|
lexer.NextToken(); |
|
|
|
#line 2885 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 174: { |
|
lexer.NextToken(); |
|
|
|
#line 2886 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 175: { |
|
lexer.NextToken(); |
|
|
|
#line 2887 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 176: { |
|
lexer.NextToken(); |
|
|
|
#line 2888 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 177: { |
|
lexer.NextToken(); |
|
|
|
#line 2889 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 178: { |
|
lexer.NextToken(); |
|
|
|
#line 2890 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 179: { |
|
lexer.NextToken(); |
|
|
|
#line 2891 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 180: { |
|
lexer.NextToken(); |
|
|
|
#line 2892 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 181: { |
|
lexer.NextToken(); |
|
|
|
#line 2893 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 182: { |
|
lexer.NextToken(); |
|
|
|
#line 2894 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 183: { |
|
lexer.NextToken(); |
|
|
|
#line 2895 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 184: { |
|
lexer.NextToken(); |
|
|
|
#line 2896 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 185: { |
|
lexer.NextToken(); |
|
|
|
#line 2897 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 186: { |
|
lexer.NextToken(); |
|
|
|
#line 2898 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 187: { |
|
lexer.NextToken(); |
|
|
|
#line 2899 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 188: { |
|
lexer.NextToken(); |
|
|
|
#line 2900 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 189: { |
|
lexer.NextToken(); |
|
|
|
#line 2901 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 190: { |
|
lexer.NextToken(); |
|
|
|
#line 2902 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 191: { |
|
lexer.NextToken(); |
|
|
|
#line 2903 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 192: { |
|
lexer.NextToken(); |
|
|
|
#line 2904 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 193: { |
|
lexer.NextToken(); |
|
|
|
#line 2905 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 196: { |
|
lexer.NextToken(); |
|
|
|
#line 2906 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 197: { |
|
lexer.NextToken(); |
|
|
|
#line 2907 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 198: { |
|
lexer.NextToken(); |
|
|
|
#line 2908 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
case 199: { |
|
lexer.NextToken(); |
|
|
|
#line 2909 "VBNET.ATG" |
|
name = t.val; |
|
break; |
|
} |
|
default: SynErr(237); break; |
|
} |
|
} |
|
|
|
void CastTarget( |
|
#line 1737 "VBNET.ATG" |
|
out TypeReference type) { |
|
|
|
#line 1739 "VBNET.ATG" |
|
type = null; |
|
|
|
switch (la.kind) { |
|
case 58: { |
|
lexer.NextToken(); |
|
|
|
#line 1741 "VBNET.ATG" |
|
type = new TypeReference("System.Boolean"); |
|
break; |
|
} |
|
case 59: { |
|
lexer.NextToken(); |
|
|
|
#line 1742 "VBNET.ATG" |
|
type = new TypeReference("System.Byte"); |
|
break; |
|
} |
|
case 60: { |
|
lexer.NextToken(); |
|
|
|
#line 1743 "VBNET.ATG" |
|
type = new TypeReference("System.Char"); |
|
break; |
|
} |
|
case 61: { |
|
lexer.NextToken(); |
|
|
|
#line 1744 "VBNET.ATG" |
|
type = new TypeReference("System.DateTime"); |
|
break; |
|
} |
|
case 63: { |
|
lexer.NextToken(); |
|
|
|
#line 1745 "VBNET.ATG" |
|
type = new TypeReference("System.Decimal"); |
|
break; |
|
} |
|
case 62: { |
|
lexer.NextToken(); |
|
|
|
#line 1746 "VBNET.ATG" |
|
type = new TypeReference("System.Double"); |
|
break; |
|
} |
|
case 65: { |
|
lexer.NextToken(); |
|
|
|
#line 1747 "VBNET.ATG" |
|
type = new TypeReference("System.Int32"); |
|
break; |
|
} |
|
case 67: { |
|
lexer.NextToken(); |
|
|
|
#line 1748 "VBNET.ATG" |
|
type = new TypeReference("System.Int64"); |
|
break; |
|
} |
|
case 68: { |
|
lexer.NextToken(); |
|
|
|
#line 1749 "VBNET.ATG" |
|
type = new TypeReference("System.Object"); |
|
break; |
|
} |
|
case 71: { |
|
lexer.NextToken(); |
|
|
|
#line 1750 "VBNET.ATG" |
|
type = new TypeReference("System.Int16"); |
|
break; |
|
} |
|
case 72: { |
|
lexer.NextToken(); |
|
|
|
#line 1751 "VBNET.ATG" |
|
type = new TypeReference("System.Single"); |
|
break; |
|
} |
|
case 73: { |
|
lexer.NextToken(); |
|
|
|
#line 1752 "VBNET.ATG" |
|
type = new TypeReference("System.String"); |
|
break; |
|
} |
|
default: SynErr(238); break; |
|
} |
|
} |
|
|
|
void Argument( |
|
#line 1913 "VBNET.ATG" |
|
out Expression argumentexpr) { |
|
|
|
#line 1915 "VBNET.ATG" |
|
Expression expr; |
|
argumentexpr = null; |
|
string name; |
|
|
|
if ( |
|
#line 1919 "VBNET.ATG" |
|
IsNamedAssign()) { |
|
Identifier(); |
|
|
|
#line 1919 "VBNET.ATG" |
|
name = t.val; |
|
Expect(13); |
|
Expect(11); |
|
Expr( |
|
#line 1919 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1921 "VBNET.ATG" |
|
argumentexpr = new NamedArgumentExpression(name, expr); |
|
|
|
} else if (StartOf(19)) { |
|
Expr( |
|
#line 1924 "VBNET.ATG" |
|
out argumentexpr); |
|
} else SynErr(239); |
|
} |
|
|
|
void ConditionalAndExpr( |
|
#line 1760 "VBNET.ATG" |
|
out Expression outExpr) { |
|
|
|
#line 1761 "VBNET.ATG" |
|
Expression expr; |
|
InclusiveOrExpr( |
|
#line 1762 "VBNET.ATG" |
|
out outExpr); |
|
while (la.kind == 45) { |
|
lexer.NextToken(); |
|
InclusiveOrExpr( |
|
#line 1762 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1762 "VBNET.ATG" |
|
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.LogicalAnd, expr); |
|
} |
|
} |
|
|
|
void InclusiveOrExpr( |
|
#line 1765 "VBNET.ATG" |
|
out Expression outExpr) { |
|
|
|
#line 1766 "VBNET.ATG" |
|
Expression expr; |
|
ExclusiveOrExpr( |
|
#line 1767 "VBNET.ATG" |
|
out outExpr); |
|
while (la.kind == 185) { |
|
lexer.NextToken(); |
|
ExclusiveOrExpr( |
|
#line 1767 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1767 "VBNET.ATG" |
|
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.ExclusiveOr, expr); |
|
} |
|
} |
|
|
|
void ExclusiveOrExpr( |
|
#line 1770 "VBNET.ATG" |
|
out Expression outExpr) { |
|
|
|
#line 1771 "VBNET.ATG" |
|
Expression expr; |
|
AndExpr( |
|
#line 1772 "VBNET.ATG" |
|
out outExpr); |
|
while (la.kind == 137) { |
|
lexer.NextToken(); |
|
AndExpr( |
|
#line 1772 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1772 "VBNET.ATG" |
|
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseOr, expr); |
|
} |
|
} |
|
|
|
void AndExpr( |
|
#line 1775 "VBNET.ATG" |
|
out Expression outExpr) { |
|
|
|
#line 1776 "VBNET.ATG" |
|
Expression expr; |
|
NotExpr( |
|
#line 1777 "VBNET.ATG" |
|
out outExpr); |
|
while (la.kind == 44) { |
|
lexer.NextToken(); |
|
NotExpr( |
|
#line 1777 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1777 "VBNET.ATG" |
|
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseAnd, expr); |
|
} |
|
} |
|
|
|
void NotExpr( |
|
#line 1780 "VBNET.ATG" |
|
out Expression outExpr) { |
|
|
|
#line 1781 "VBNET.ATG" |
|
UnaryOperatorType uop = UnaryOperatorType.None; |
|
while (la.kind == 128) { |
|
lexer.NextToken(); |
|
|
|
#line 1782 "VBNET.ATG" |
|
uop = UnaryOperatorType.Not; |
|
} |
|
EqualityExpr( |
|
#line 1783 "VBNET.ATG" |
|
out outExpr); |
|
|
|
#line 1784 "VBNET.ATG" |
|
if (uop != UnaryOperatorType.None) |
|
outExpr = new UnaryOperatorExpression(outExpr, uop); |
|
|
|
} |
|
|
|
void EqualityExpr( |
|
#line 1789 "VBNET.ATG" |
|
out Expression outExpr) { |
|
|
|
#line 1791 "VBNET.ATG" |
|
Expression expr; |
|
BinaryOperatorType op = BinaryOperatorType.None; |
|
|
|
RelationalExpr( |
|
#line 1794 "VBNET.ATG" |
|
out outExpr); |
|
while (la.kind == 11 || la.kind == 27 || la.kind == 115) { |
|
if (la.kind == 27) { |
|
lexer.NextToken(); |
|
|
|
#line 1797 "VBNET.ATG" |
|
op = BinaryOperatorType.InEquality; |
|
} else if (la.kind == 11) { |
|
lexer.NextToken(); |
|
|
|
#line 1798 "VBNET.ATG" |
|
op = BinaryOperatorType.Equality; |
|
} else { |
|
lexer.NextToken(); |
|
|
|
#line 1799 "VBNET.ATG" |
|
op = BinaryOperatorType.Like; |
|
} |
|
RelationalExpr( |
|
#line 1801 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1801 "VBNET.ATG" |
|
outExpr = new BinaryOperatorExpression(outExpr, op, expr); |
|
} |
|
} |
|
|
|
void RelationalExpr( |
|
#line 1805 "VBNET.ATG" |
|
out Expression outExpr) { |
|
|
|
#line 1807 "VBNET.ATG" |
|
Expression expr; |
|
BinaryOperatorType op = BinaryOperatorType.None; |
|
|
|
ShiftExpr( |
|
#line 1810 "VBNET.ATG" |
|
out outExpr); |
|
while (StartOf(25)) { |
|
if (StartOf(26)) { |
|
if (la.kind == 26) { |
|
lexer.NextToken(); |
|
|
|
#line 1813 "VBNET.ATG" |
|
op = BinaryOperatorType.LessThan; |
|
} else if (la.kind == 25) { |
|
lexer.NextToken(); |
|
|
|
#line 1814 "VBNET.ATG" |
|
op = BinaryOperatorType.GreaterThan; |
|
} else if (la.kind == 29) { |
|
lexer.NextToken(); |
|
|
|
#line 1815 "VBNET.ATG" |
|
op = BinaryOperatorType.LessThanOrEqual; |
|
} else if (la.kind == 28) { |
|
lexer.NextToken(); |
|
|
|
#line 1816 "VBNET.ATG" |
|
op = BinaryOperatorType.GreaterThanOrEqual; |
|
} else SynErr(240); |
|
ShiftExpr( |
|
#line 1818 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1818 "VBNET.ATG" |
|
outExpr = new BinaryOperatorExpression(outExpr, op, expr); |
|
} else { |
|
if (la.kind == 112) { |
|
lexer.NextToken(); |
|
|
|
#line 1821 "VBNET.ATG" |
|
op = BinaryOperatorType.ReferenceEquality; |
|
} else if (la.kind == 189) { |
|
lexer.NextToken(); |
|
|
|
#line 1822 "VBNET.ATG" |
|
op = BinaryOperatorType.ReferenceInequality; |
|
} else SynErr(241); |
|
Expr( |
|
#line 1823 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1823 "VBNET.ATG" |
|
outExpr = new BinaryOperatorExpression(outExpr, op, expr); |
|
} |
|
} |
|
} |
|
|
|
void ShiftExpr( |
|
#line 1827 "VBNET.ATG" |
|
out Expression outExpr) { |
|
|
|
#line 1829 "VBNET.ATG" |
|
Expression expr; |
|
BinaryOperatorType op = BinaryOperatorType.None; |
|
|
|
AdditiveExpr( |
|
#line 1832 "VBNET.ATG" |
|
out outExpr); |
|
while (la.kind == 30 || la.kind == 31) { |
|
if (la.kind == 30) { |
|
lexer.NextToken(); |
|
|
|
#line 1835 "VBNET.ATG" |
|
op = BinaryOperatorType.ShiftLeft; |
|
} else { |
|
lexer.NextToken(); |
|
|
|
#line 1836 "VBNET.ATG" |
|
op = BinaryOperatorType.ShiftRight; |
|
} |
|
AdditiveExpr( |
|
#line 1838 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1838 "VBNET.ATG" |
|
outExpr = new BinaryOperatorExpression(outExpr, op, expr); |
|
} |
|
} |
|
|
|
void AdditiveExpr( |
|
#line 1842 "VBNET.ATG" |
|
out Expression outExpr) { |
|
|
|
#line 1844 "VBNET.ATG" |
|
Expression expr; |
|
BinaryOperatorType op = BinaryOperatorType.None; |
|
|
|
MultiplicativeExpr( |
|
#line 1847 "VBNET.ATG" |
|
out outExpr); |
|
while (la.kind == 14 || la.kind == 15 || la.kind == 19) { |
|
if (la.kind == 14) { |
|
lexer.NextToken(); |
|
|
|
#line 1850 "VBNET.ATG" |
|
op = BinaryOperatorType.Add; |
|
} else if (la.kind == 15) { |
|
lexer.NextToken(); |
|
|
|
#line 1851 "VBNET.ATG" |
|
op = BinaryOperatorType.Subtract; |
|
} else { |
|
lexer.NextToken(); |
|
|
|
#line 1852 "VBNET.ATG" |
|
op = BinaryOperatorType.Concat; |
|
} |
|
MultiplicativeExpr( |
|
#line 1854 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1854 "VBNET.ATG" |
|
outExpr = new BinaryOperatorExpression(outExpr, op, expr); |
|
} |
|
} |
|
|
|
void MultiplicativeExpr( |
|
#line 1858 "VBNET.ATG" |
|
out Expression outExpr) { |
|
|
|
#line 1860 "VBNET.ATG" |
|
Expression expr; |
|
BinaryOperatorType op = BinaryOperatorType.None; |
|
|
|
UnaryExpr( |
|
#line 1863 "VBNET.ATG" |
|
out outExpr); |
|
while (StartOf(27)) { |
|
if (la.kind == 16) { |
|
lexer.NextToken(); |
|
|
|
#line 1866 "VBNET.ATG" |
|
op = BinaryOperatorType.Multiply; |
|
} else if (la.kind == 17) { |
|
lexer.NextToken(); |
|
|
|
#line 1867 "VBNET.ATG" |
|
op = BinaryOperatorType.Divide; |
|
} else if (la.kind == 18) { |
|
lexer.NextToken(); |
|
|
|
#line 1868 "VBNET.ATG" |
|
op = BinaryOperatorType.DivideInteger; |
|
} else if (la.kind == 119) { |
|
lexer.NextToken(); |
|
|
|
#line 1869 "VBNET.ATG" |
|
op = BinaryOperatorType.Modulus; |
|
} else { |
|
lexer.NextToken(); |
|
|
|
#line 1870 "VBNET.ATG" |
|
op = BinaryOperatorType.Power; |
|
} |
|
UnaryExpr( |
|
#line 1872 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1872 "VBNET.ATG" |
|
outExpr = new BinaryOperatorExpression(outExpr, op, expr); |
|
} |
|
} |
|
|
|
void NonArrayTypeName( |
|
#line 1941 "VBNET.ATG" |
|
out TypeReference typeref) { |
|
|
|
#line 1943 "VBNET.ATG" |
|
string name; |
|
typeref = null; |
|
|
|
if (StartOf(10)) { |
|
Qualident( |
|
#line 1946 "VBNET.ATG" |
|
out name); |
|
|
|
#line 1946 "VBNET.ATG" |
|
typeref = new TypeReference(name); |
|
if ( |
|
#line 1947 "VBNET.ATG" |
|
la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) { |
|
lexer.NextToken(); |
|
Expect(196); |
|
TypeArgumentList( |
|
#line 1948 "VBNET.ATG" |
|
typeref.GenericTypes); |
|
Expect(24); |
|
} |
|
} else if (la.kind == 132) { |
|
lexer.NextToken(); |
|
|
|
#line 1950 "VBNET.ATG" |
|
typeref = new TypeReference("System.Object"); |
|
} else if (la.kind == 194) { |
|
lexer.NextToken(); |
|
Expect(10); |
|
Qualident( |
|
#line 1951 "VBNET.ATG" |
|
out name); |
|
|
|
#line 1952 "VBNET.ATG" |
|
typeref = new TypeReference(name); typeref.IsGlobal = true; |
|
if ( |
|
#line 1953 "VBNET.ATG" |
|
la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) { |
|
lexer.NextToken(); |
|
Expect(196); |
|
TypeArgumentList( |
|
#line 1954 "VBNET.ATG" |
|
typeref.GenericTypes); |
|
Expect(24); |
|
} |
|
} else if (StartOf(22)) { |
|
PrimitiveTypeName( |
|
#line 1956 "VBNET.ATG" |
|
out name); |
|
|
|
#line 1956 "VBNET.ATG" |
|
typeref = new TypeReference(name); |
|
} else SynErr(242); |
|
} |
|
|
|
void ArgumentList( |
|
#line 1898 "VBNET.ATG" |
|
out ArrayList arguments) { |
|
|
|
#line 1900 "VBNET.ATG" |
|
arguments = new ArrayList(); |
|
Expression expr = null; |
|
|
|
if (StartOf(19)) { |
|
Argument( |
|
#line 1904 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1904 "VBNET.ATG" |
|
if (expr != null) { arguments.Add(expr); } |
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
Argument( |
|
#line 1907 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 1907 "VBNET.ATG" |
|
if (expr != null) { arguments.Add(expr); } |
|
} |
|
} |
|
} |
|
|
|
void ArrayTypeModifiers( |
|
#line 1969 "VBNET.ATG" |
|
out ArrayList arrayModifiers) { |
|
|
|
#line 1971 "VBNET.ATG" |
|
arrayModifiers = new ArrayList(); |
|
int i = 0; |
|
|
|
while ( |
|
#line 1974 "VBNET.ATG" |
|
IsDims()) { |
|
Expect(23); |
|
if (la.kind == 12 || la.kind == 24) { |
|
RankList( |
|
#line 1976 "VBNET.ATG" |
|
out i); |
|
} |
|
|
|
#line 1978 "VBNET.ATG" |
|
arrayModifiers.Add(i); |
|
|
|
Expect(24); |
|
} |
|
|
|
#line 1983 "VBNET.ATG" |
|
if(arrayModifiers.Count == 0) { |
|
arrayModifiers = null; |
|
} |
|
|
|
} |
|
|
|
void TypeArgumentList( |
|
#line 1996 "VBNET.ATG" |
|
List<TypeReference> typeArguments) { |
|
|
|
#line 1998 "VBNET.ATG" |
|
TypeReference typeref; |
|
|
|
TypeName( |
|
#line 2000 "VBNET.ATG" |
|
out typeref); |
|
|
|
#line 2000 "VBNET.ATG" |
|
if (typeref != null) typeArguments.Add(typeref); |
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 2003 "VBNET.ATG" |
|
out typeref); |
|
|
|
#line 2003 "VBNET.ATG" |
|
if (typeref != null) typeArguments.Add(typeref); |
|
} |
|
} |
|
|
|
void RankList( |
|
#line 1990 "VBNET.ATG" |
|
out int i) { |
|
|
|
#line 1991 "VBNET.ATG" |
|
i = 0; |
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
|
|
#line 1992 "VBNET.ATG" |
|
++i; |
|
} |
|
} |
|
|
|
void Attribute( |
|
#line 2028 "VBNET.ATG" |
|
out ICSharpCode.NRefactory.Parser.AST.Attribute attribute) { |
|
|
|
#line 2029 "VBNET.ATG" |
|
string name; |
|
Qualident( |
|
#line 2030 "VBNET.ATG" |
|
out name); |
|
|
|
#line 2031 "VBNET.ATG" |
|
List<Expression> positional = new List<Expression>(); |
|
List<NamedArgumentExpression> named = new List<NamedArgumentExpression>(); |
|
|
|
if (la.kind == 23) { |
|
AttributeArguments( |
|
#line 2034 "VBNET.ATG" |
|
positional, named); |
|
} |
|
|
|
#line 2036 "VBNET.ATG" |
|
attribute = new ICSharpCode.NRefactory.Parser.AST.Attribute(name, positional, named); |
|
|
|
} |
|
|
|
void AttributeArguments( |
|
#line 2041 "VBNET.ATG" |
|
List<Expression> positional, List<NamedArgumentExpression> named) { |
|
|
|
#line 2043 "VBNET.ATG" |
|
bool nameFound = false; |
|
string name = ""; |
|
Expression expr; |
|
|
|
Expect(23); |
|
if ( |
|
#line 2049 "VBNET.ATG" |
|
IsNotClosingParenthesis()) { |
|
if ( |
|
#line 2051 "VBNET.ATG" |
|
IsNamedAssign()) { |
|
|
|
#line 2051 "VBNET.ATG" |
|
nameFound = true; |
|
IdentifierOrKeyword( |
|
#line 2052 "VBNET.ATG" |
|
out name); |
|
if (la.kind == 13) { |
|
lexer.NextToken(); |
|
} |
|
Expect(11); |
|
} |
|
Expr( |
|
#line 2054 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 2056 "VBNET.ATG" |
|
if (expr != null) { if(name == "") positional.Add(expr); |
|
else { named.Add(new NamedArgumentExpression(name, expr)); name = ""; } |
|
} |
|
|
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
if ( |
|
#line 2063 "VBNET.ATG" |
|
IsNamedAssign()) { |
|
|
|
#line 2063 "VBNET.ATG" |
|
nameFound = true; |
|
IdentifierOrKeyword( |
|
#line 2064 "VBNET.ATG" |
|
out name); |
|
if (la.kind == 13) { |
|
lexer.NextToken(); |
|
} |
|
Expect(11); |
|
} else if (StartOf(19)) { |
|
|
|
#line 2066 "VBNET.ATG" |
|
if (nameFound) Error("no positional argument after named argument"); |
|
} else SynErr(243); |
|
Expr( |
|
#line 2067 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 2067 "VBNET.ATG" |
|
if (expr != null) { if(name == "") positional.Add(expr); |
|
else { named.Add(new NamedArgumentExpression(name, expr)); name = ""; } |
|
} |
|
|
|
} |
|
} |
|
Expect(24); |
|
} |
|
|
|
void FormalParameter( |
|
#line 2136 "VBNET.ATG" |
|
out ParameterDeclarationExpression p) { |
|
|
|
#line 2138 "VBNET.ATG" |
|
TypeReference type = null; |
|
ParamModifiers mod = new ParamModifiers(this); |
|
Expression expr = null; |
|
p = null;ArrayList arrayModifiers = null; |
|
|
|
while (StartOf(28)) { |
|
ParameterModifier( |
|
#line 2143 "VBNET.ATG" |
|
mod); |
|
} |
|
Identifier(); |
|
|
|
#line 2144 "VBNET.ATG" |
|
string parameterName = t.val; |
|
if ( |
|
#line 2145 "VBNET.ATG" |
|
IsDims()) { |
|
ArrayTypeModifiers( |
|
#line 2145 "VBNET.ATG" |
|
out arrayModifiers); |
|
} |
|
if (la.kind == 47) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 2146 "VBNET.ATG" |
|
out type); |
|
} |
|
|
|
#line 2148 "VBNET.ATG" |
|
if(type != null) { |
|
if (arrayModifiers != null) { |
|
if (type.RankSpecifier != null) { |
|
Error("array rank only allowed one time"); |
|
} else { |
|
type.RankSpecifier = (int[])arrayModifiers.ToArray(typeof(int)); |
|
} |
|
} |
|
} else { |
|
type = new TypeReference("System.Object", arrayModifiers == null ? null : (int[])arrayModifiers.ToArray(typeof(int))); |
|
} |
|
|
|
if (la.kind == 11) { |
|
lexer.NextToken(); |
|
Expr( |
|
#line 2160 "VBNET.ATG" |
|
out expr); |
|
} |
|
|
|
#line 2162 "VBNET.ATG" |
|
mod.Check(); |
|
p = new ParameterDeclarationExpression(type, parameterName, mod.Modifier, expr); |
|
|
|
} |
|
|
|
void ParameterModifier( |
|
#line 2933 "VBNET.ATG" |
|
ParamModifiers m) { |
|
if (la.kind == 54) { |
|
lexer.NextToken(); |
|
|
|
#line 2934 "VBNET.ATG" |
|
m.Add(ParamModifier.In); |
|
} else if (la.kind == 52) { |
|
lexer.NextToken(); |
|
|
|
#line 2935 "VBNET.ATG" |
|
m.Add(ParamModifier.Ref); |
|
} else if (la.kind == 136) { |
|
lexer.NextToken(); |
|
|
|
#line 2936 "VBNET.ATG" |
|
m.Add(ParamModifier.Optional); |
|
} else if (la.kind == 143) { |
|
lexer.NextToken(); |
|
|
|
#line 2937 "VBNET.ATG" |
|
m.Add(ParamModifier.Params); |
|
} else SynErr(244); |
|
} |
|
|
|
void Statement() { |
|
|
|
#line 2190 "VBNET.ATG" |
|
Statement stmt = null; |
|
Point startPos = la.Location; |
|
string label = String.Empty; |
|
|
|
|
|
if (la.kind == 1 || la.kind == 13) { |
|
} else if ( |
|
#line 2196 "VBNET.ATG" |
|
IsLabel()) { |
|
LabelName( |
|
#line 2196 "VBNET.ATG" |
|
out label); |
|
|
|
#line 2198 "VBNET.ATG" |
|
compilationUnit.AddChild(new LabelStatement(t.val)); |
|
|
|
Expect(13); |
|
Statement(); |
|
} else if (StartOf(29)) { |
|
EmbeddedStatement( |
|
#line 2201 "VBNET.ATG" |
|
out stmt); |
|
|
|
#line 2201 "VBNET.ATG" |
|
compilationUnit.AddChild(stmt); |
|
} else if (StartOf(30)) { |
|
LocalDeclarationStatement( |
|
#line 2202 "VBNET.ATG" |
|
out stmt); |
|
|
|
#line 2202 "VBNET.ATG" |
|
compilationUnit.AddChild(stmt); |
|
} else SynErr(245); |
|
|
|
#line 2205 "VBNET.ATG" |
|
if (stmt != null) { |
|
stmt.StartLocation = startPos; |
|
stmt.EndLocation = t.Location; |
|
} |
|
|
|
} |
|
|
|
void LabelName( |
|
#line 2586 "VBNET.ATG" |
|
out string name) { |
|
|
|
#line 2588 "VBNET.ATG" |
|
name = String.Empty; |
|
|
|
if (StartOf(10)) { |
|
Identifier(); |
|
|
|
#line 2590 "VBNET.ATG" |
|
name = t.val; |
|
} else if (la.kind == 5) { |
|
lexer.NextToken(); |
|
|
|
#line 2591 "VBNET.ATG" |
|
name = t.val; |
|
} else SynErr(246); |
|
} |
|
|
|
void EmbeddedStatement( |
|
#line 2244 "VBNET.ATG" |
|
out Statement statement) { |
|
|
|
#line 2246 "VBNET.ATG" |
|
Statement embeddedStatement = null; |
|
statement = null; |
|
Expression expr = null; |
|
string name = String.Empty;ArrayList p = null; |
|
|
|
switch (la.kind) { |
|
case 93: { |
|
lexer.NextToken(); |
|
|
|
#line 2251 "VBNET.ATG" |
|
ExitType exitType = ExitType.None; |
|
switch (la.kind) { |
|
case 167: { |
|
lexer.NextToken(); |
|
|
|
#line 2253 "VBNET.ATG" |
|
exitType = ExitType.Sub; |
|
break; |
|
} |
|
case 99: { |
|
lexer.NextToken(); |
|
|
|
#line 2255 "VBNET.ATG" |
|
exitType = ExitType.Function; |
|
break; |
|
} |
|
case 146: { |
|
lexer.NextToken(); |
|
|
|
#line 2257 "VBNET.ATG" |
|
exitType = ExitType.Property; |
|
break; |
|
} |
|
case 82: { |
|
lexer.NextToken(); |
|
|
|
#line 2259 "VBNET.ATG" |
|
exitType = ExitType.Do; |
|
break; |
|
} |
|
case 97: { |
|
lexer.NextToken(); |
|
|
|
#line 2261 "VBNET.ATG" |
|
exitType = ExitType.For; |
|
break; |
|
} |
|
case 174: { |
|
lexer.NextToken(); |
|
|
|
#line 2263 "VBNET.ATG" |
|
exitType = ExitType.Try; |
|
break; |
|
} |
|
case 181: { |
|
lexer.NextToken(); |
|
|
|
#line 2265 "VBNET.ATG" |
|
exitType = ExitType.While; |
|
break; |
|
} |
|
case 155: { |
|
lexer.NextToken(); |
|
|
|
#line 2267 "VBNET.ATG" |
|
exitType = ExitType.Select; |
|
break; |
|
} |
|
default: SynErr(247); break; |
|
} |
|
|
|
#line 2269 "VBNET.ATG" |
|
statement = new ExitStatement(exitType); |
|
break; |
|
} |
|
case 174: { |
|
TryStatement( |
|
#line 2270 "VBNET.ATG" |
|
out statement); |
|
break; |
|
} |
|
case 186: { |
|
lexer.NextToken(); |
|
|
|
#line 2271 "VBNET.ATG" |
|
ContinueType continueType = ContinueType.None; |
|
if (la.kind == 82 || la.kind == 97 || la.kind == 181) { |
|
if (la.kind == 82) { |
|
lexer.NextToken(); |
|
|
|
#line 2271 "VBNET.ATG" |
|
continueType = ContinueType.Do; |
|
} else if (la.kind == 97) { |
|
lexer.NextToken(); |
|
|
|
#line 2271 "VBNET.ATG" |
|
continueType = ContinueType.For; |
|
} else { |
|
lexer.NextToken(); |
|
|
|
#line 2271 "VBNET.ATG" |
|
continueType = ContinueType.While; |
|
} |
|
} |
|
|
|
#line 2271 "VBNET.ATG" |
|
statement = new ContinueStatement(continueType); |
|
break; |
|
} |
|
case 171: { |
|
lexer.NextToken(); |
|
if (StartOf(19)) { |
|
Expr( |
|
#line 2273 "VBNET.ATG" |
|
out expr); |
|
} |
|
|
|
#line 2273 "VBNET.ATG" |
|
statement = new ThrowStatement(expr); |
|
break; |
|
} |
|
case 154: { |
|
lexer.NextToken(); |
|
if (StartOf(19)) { |
|
Expr( |
|
#line 2275 "VBNET.ATG" |
|
out expr); |
|
} |
|
|
|
#line 2275 "VBNET.ATG" |
|
statement = new ReturnStatement(expr); |
|
break; |
|
} |
|
case 168: { |
|
lexer.NextToken(); |
|
Expr( |
|
#line 2277 "VBNET.ATG" |
|
out expr); |
|
EndOfStmt(); |
|
Block( |
|
#line 2277 "VBNET.ATG" |
|
out embeddedStatement); |
|
Expect(87); |
|
Expect(168); |
|
|
|
#line 2278 "VBNET.ATG" |
|
statement = new LockStatement(expr, embeddedStatement); |
|
break; |
|
} |
|
case 149: { |
|
lexer.NextToken(); |
|
Identifier(); |
|
|
|
#line 2280 "VBNET.ATG" |
|
name = t.val; |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(18)) { |
|
ArgumentList( |
|
#line 2281 "VBNET.ATG" |
|
out p); |
|
} |
|
Expect(24); |
|
} |
|
|
|
#line 2282 "VBNET.ATG" |
|
statement = new RaiseEventStatement(name, p); |
|
break; |
|
} |
|
case 182: { |
|
WithStatement( |
|
#line 2284 "VBNET.ATG" |
|
out statement); |
|
break; |
|
} |
|
case 41: { |
|
lexer.NextToken(); |
|
|
|
#line 2286 "VBNET.ATG" |
|
Expression handlerExpr = null; |
|
Expr( |
|
#line 2287 "VBNET.ATG" |
|
out expr); |
|
Expect(12); |
|
Expr( |
|
#line 2287 "VBNET.ATG" |
|
out handlerExpr); |
|
|
|
#line 2289 "VBNET.ATG" |
|
statement = new AddHandlerStatement(expr, handlerExpr); |
|
|
|
break; |
|
} |
|
case 152: { |
|
lexer.NextToken(); |
|
|
|
#line 2292 "VBNET.ATG" |
|
Expression handlerExpr = null; |
|
Expr( |
|
#line 2293 "VBNET.ATG" |
|
out expr); |
|
Expect(12); |
|
Expr( |
|
#line 2293 "VBNET.ATG" |
|
out handlerExpr); |
|
|
|
#line 2295 "VBNET.ATG" |
|
statement = new RemoveHandlerStatement(expr, handlerExpr); |
|
|
|
break; |
|
} |
|
case 181: { |
|
lexer.NextToken(); |
|
Expr( |
|
#line 2298 "VBNET.ATG" |
|
out expr); |
|
EndOfStmt(); |
|
Block( |
|
#line 2299 "VBNET.ATG" |
|
out embeddedStatement); |
|
Expect(87); |
|
Expect(181); |
|
|
|
#line 2301 "VBNET.ATG" |
|
statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.Start); |
|
|
|
break; |
|
} |
|
case 82: { |
|
lexer.NextToken(); |
|
|
|
#line 2306 "VBNET.ATG" |
|
ConditionType conditionType = ConditionType.None; |
|
|
|
if (la.kind == 177 || la.kind == 181) { |
|
WhileOrUntil( |
|
#line 2309 "VBNET.ATG" |
|
out conditionType); |
|
Expr( |
|
#line 2309 "VBNET.ATG" |
|
out expr); |
|
EndOfStmt(); |
|
Block( |
|
#line 2310 "VBNET.ATG" |
|
out embeddedStatement); |
|
Expect(117); |
|
|
|
#line 2313 "VBNET.ATG" |
|
statement = new DoLoopStatement(expr, |
|
embeddedStatement, |
|
conditionType == ConditionType.While ? ConditionType.DoWhile : conditionType, |
|
ConditionPosition.Start); |
|
|
|
} else if (la.kind == 1 || la.kind == 13) { |
|
EndOfStmt(); |
|
Block( |
|
#line 2320 "VBNET.ATG" |
|
out embeddedStatement); |
|
Expect(117); |
|
if (la.kind == 177 || la.kind == 181) { |
|
WhileOrUntil( |
|
#line 2321 "VBNET.ATG" |
|
out conditionType); |
|
Expr( |
|
#line 2321 "VBNET.ATG" |
|
out expr); |
|
} |
|
|
|
#line 2323 "VBNET.ATG" |
|
statement = new DoLoopStatement(expr, embeddedStatement, conditionType, ConditionPosition.End); |
|
|
|
} else SynErr(248); |
|
break; |
|
} |
|
case 97: { |
|
lexer.NextToken(); |
|
|
|
#line 2328 "VBNET.ATG" |
|
Expression group = null; |
|
TypeReference typeReference; |
|
string typeName; |
|
Point startLocation = t.Location; |
|
|
|
if (la.kind == 84) { |
|
lexer.NextToken(); |
|
LoopControlVariable( |
|
#line 2335 "VBNET.ATG" |
|
out typeReference, out typeName); |
|
Expect(108); |
|
Expr( |
|
#line 2336 "VBNET.ATG" |
|
out group); |
|
EndOfStmt(); |
|
Block( |
|
#line 2337 "VBNET.ATG" |
|
out embeddedStatement); |
|
Expect(127); |
|
if (StartOf(19)) { |
|
Expr( |
|
#line 2338 "VBNET.ATG" |
|
out expr); |
|
} |
|
|
|
#line 2340 "VBNET.ATG" |
|
statement = new ForeachStatement(typeReference, |
|
typeName, |
|
group, |
|
embeddedStatement, |
|
expr); |
|
statement.StartLocation = startLocation; |
|
statement.EndLocation = t.EndLocation; |
|
|
|
|
|
} else if (StartOf(10)) { |
|
|
|
#line 2351 "VBNET.ATG" |
|
Expression start = null; |
|
Expression end = null; |
|
Expression step = null; |
|
Expression nextExpr = null;ArrayList nextExpressions = null; |
|
|
|
LoopControlVariable( |
|
#line 2356 "VBNET.ATG" |
|
out typeReference, out typeName); |
|
Expect(11); |
|
Expr( |
|
#line 2357 "VBNET.ATG" |
|
out start); |
|
Expect(172); |
|
Expr( |
|
#line 2357 "VBNET.ATG" |
|
out end); |
|
if (la.kind == 162) { |
|
lexer.NextToken(); |
|
Expr( |
|
#line 2357 "VBNET.ATG" |
|
out step); |
|
} |
|
EndOfStmt(); |
|
Block( |
|
#line 2358 "VBNET.ATG" |
|
out embeddedStatement); |
|
Expect(127); |
|
if (StartOf(19)) { |
|
Expr( |
|
#line 2361 "VBNET.ATG" |
|
out nextExpr); |
|
|
|
#line 2361 "VBNET.ATG" |
|
nextExpressions = new ArrayList(); nextExpressions.Add(nextExpr); |
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
Expr( |
|
#line 2362 "VBNET.ATG" |
|
out nextExpr); |
|
|
|
#line 2362 "VBNET.ATG" |
|
nextExpressions.Add(nextExpr); |
|
} |
|
} |
|
|
|
#line 2365 "VBNET.ATG" |
|
statement = new ForNextStatement(typeReference, typeName, start, end, step, embeddedStatement, nextExpressions); |
|
|
|
} else SynErr(249); |
|
break; |
|
} |
|
case 91: { |
|
lexer.NextToken(); |
|
Expr( |
|
#line 2369 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 2369 "VBNET.ATG" |
|
statement = new ErrorStatement(expr); |
|
break; |
|
} |
|
case 151: { |
|
lexer.NextToken(); |
|
|
|
#line 2371 "VBNET.ATG" |
|
Expression redimclause = null; bool isPreserve = false; |
|
if (la.kind == 144) { |
|
lexer.NextToken(); |
|
|
|
#line 2371 "VBNET.ATG" |
|
isPreserve = true; |
|
} |
|
Expr( |
|
#line 2372 "VBNET.ATG" |
|
out redimclause); |
|
|
|
#line 2374 "VBNET.ATG" |
|
ReDimStatement reDimStatement = new ReDimStatement(isPreserve); |
|
statement = reDimStatement; |
|
reDimStatement.ReDimClauses.Add(redimclause as InvocationExpression); |
|
|
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
Expr( |
|
#line 2378 "VBNET.ATG" |
|
out redimclause); |
|
|
|
#line 2378 "VBNET.ATG" |
|
reDimStatement.ReDimClauses.Add(redimclause as InvocationExpression); |
|
} |
|
break; |
|
} |
|
case 90: { |
|
lexer.NextToken(); |
|
Expr( |
|
#line 2381 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 2382 "VBNET.ATG" |
|
ArrayList arrays = new ArrayList(); |
|
if (expr != null) { arrays.Add(expr);} |
|
EraseStatement eraseStatement = new EraseStatement(arrays); |
|
|
|
|
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
Expr( |
|
#line 2387 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 2387 "VBNET.ATG" |
|
if (expr != null) { arrays.Add(expr); } |
|
} |
|
|
|
#line 2388 "VBNET.ATG" |
|
statement = eraseStatement; |
|
break; |
|
} |
|
case 163: { |
|
lexer.NextToken(); |
|
|
|
#line 2390 "VBNET.ATG" |
|
statement = new StopStatement(); |
|
break; |
|
} |
|
case 105: { |
|
lexer.NextToken(); |
|
Expr( |
|
#line 2392 "VBNET.ATG" |
|
out expr); |
|
if (la.kind == 170) { |
|
lexer.NextToken(); |
|
} |
|
if ( |
|
#line 2394 "VBNET.ATG" |
|
IsEndStmtAhead()) { |
|
Expect(87); |
|
|
|
#line 2394 "VBNET.ATG" |
|
statement = new IfElseStatement(expr, new EndStatement()); |
|
} else if (la.kind == 1 || la.kind == 13) { |
|
EndOfStmt(); |
|
Block( |
|
#line 2397 "VBNET.ATG" |
|
out embeddedStatement); |
|
|
|
#line 2399 "VBNET.ATG" |
|
IfElseStatement ifStatement = new IfElseStatement(expr, embeddedStatement); |
|
|
|
while (la.kind == 86 || |
|
#line 2403 "VBNET.ATG" |
|
IsElseIf()) { |
|
if ( |
|
#line 2403 "VBNET.ATG" |
|
IsElseIf()) { |
|
Expect(85); |
|
Expect(105); |
|
} else { |
|
lexer.NextToken(); |
|
} |
|
|
|
#line 2406 "VBNET.ATG" |
|
Expression condition = null; Statement block = null; |
|
Expr( |
|
#line 2407 "VBNET.ATG" |
|
out condition); |
|
if (la.kind == 170) { |
|
lexer.NextToken(); |
|
} |
|
EndOfStmt(); |
|
Block( |
|
#line 2408 "VBNET.ATG" |
|
out block); |
|
|
|
#line 2410 "VBNET.ATG" |
|
ifStatement.ElseIfSections.Add(new ElseIfSection(condition, block)); |
|
|
|
} |
|
if (la.kind == 85) { |
|
lexer.NextToken(); |
|
EndOfStmt(); |
|
Block( |
|
#line 2415 "VBNET.ATG" |
|
out embeddedStatement); |
|
|
|
#line 2417 "VBNET.ATG" |
|
ifStatement.FalseStatement.Add(embeddedStatement); |
|
|
|
} |
|
Expect(87); |
|
Expect(105); |
|
|
|
#line 2421 "VBNET.ATG" |
|
statement = ifStatement; |
|
|
|
} else if (StartOf(29)) { |
|
EmbeddedStatement( |
|
#line 2424 "VBNET.ATG" |
|
out embeddedStatement); |
|
|
|
#line 2426 "VBNET.ATG" |
|
IfElseStatement ifStatement = new IfElseStatement(expr, embeddedStatement); |
|
|
|
while (la.kind == 13) { |
|
lexer.NextToken(); |
|
EmbeddedStatement( |
|
#line 2428 "VBNET.ATG" |
|
out embeddedStatement); |
|
|
|
#line 2428 "VBNET.ATG" |
|
ifStatement.TrueStatement.Add(embeddedStatement); |
|
} |
|
if (la.kind == 85) { |
|
lexer.NextToken(); |
|
if (StartOf(29)) { |
|
EmbeddedStatement( |
|
#line 2430 "VBNET.ATG" |
|
out embeddedStatement); |
|
} |
|
|
|
#line 2432 "VBNET.ATG" |
|
ifStatement.FalseStatement.Add(embeddedStatement); |
|
|
|
while (la.kind == 13) { |
|
lexer.NextToken(); |
|
EmbeddedStatement( |
|
#line 2435 "VBNET.ATG" |
|
out embeddedStatement); |
|
|
|
#line 2436 "VBNET.ATG" |
|
ifStatement.FalseStatement.Add(embeddedStatement); |
|
} |
|
} |
|
|
|
#line 2439 "VBNET.ATG" |
|
statement = ifStatement; |
|
} else SynErr(250); |
|
break; |
|
} |
|
case 155: { |
|
lexer.NextToken(); |
|
if (la.kind == 56) { |
|
lexer.NextToken(); |
|
} |
|
Expr( |
|
#line 2442 "VBNET.ATG" |
|
out expr); |
|
EndOfStmt(); |
|
|
|
#line 2443 "VBNET.ATG" |
|
ArrayList selectSections = new ArrayList(); |
|
Statement block = null; |
|
|
|
while (la.kind == 56) { |
|
|
|
#line 2447 "VBNET.ATG" |
|
ArrayList caseClauses = null; |
|
lexer.NextToken(); |
|
CaseClauses( |
|
#line 2448 "VBNET.ATG" |
|
out caseClauses); |
|
if ( |
|
#line 2448 "VBNET.ATG" |
|
IsNotStatementSeparator()) { |
|
lexer.NextToken(); |
|
} |
|
EndOfStmt(); |
|
|
|
#line 2450 "VBNET.ATG" |
|
SwitchSection selectSection = new SwitchSection(caseClauses); |
|
|
|
Block( |
|
#line 2452 "VBNET.ATG" |
|
out block); |
|
|
|
#line 2454 "VBNET.ATG" |
|
selectSection.Children = block.Children; |
|
selectSections.Add(selectSection); |
|
|
|
} |
|
|
|
#line 2458 "VBNET.ATG" |
|
statement = new SwitchStatement(expr, selectSections); |
|
Expect(87); |
|
Expect(155); |
|
break; |
|
} |
|
case 134: { |
|
|
|
#line 2460 "VBNET.ATG" |
|
OnErrorStatement onErrorStatement = null; |
|
OnErrorStatement( |
|
#line 2461 "VBNET.ATG" |
|
out onErrorStatement); |
|
|
|
#line 2461 "VBNET.ATG" |
|
statement = onErrorStatement; |
|
break; |
|
} |
|
case 103: { |
|
|
|
#line 2462 "VBNET.ATG" |
|
GotoStatement goToStatement = null; |
|
GotoStatement( |
|
#line 2463 "VBNET.ATG" |
|
out goToStatement); |
|
|
|
#line 2463 "VBNET.ATG" |
|
statement = goToStatement; |
|
break; |
|
} |
|
case 153: { |
|
|
|
#line 2464 "VBNET.ATG" |
|
ResumeStatement resumeStatement = null; |
|
ResumeStatement( |
|
#line 2465 "VBNET.ATG" |
|
out resumeStatement); |
|
|
|
#line 2465 "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: case 195: { |
|
|
|
#line 2468 "VBNET.ATG" |
|
Expression val = null; |
|
AssignmentOperatorType op; |
|
|
|
bool mustBeAssignment = la.kind == Tokens.Plus || la.kind == Tokens.Minus || |
|
la.kind == Tokens.Not || la.kind == Tokens.Times; |
|
|
|
UnaryExpr( |
|
#line 2474 "VBNET.ATG" |
|
out expr); |
|
if (StartOf(31)) { |
|
AssignmentOperator( |
|
#line 2476 "VBNET.ATG" |
|
out op); |
|
Expr( |
|
#line 2476 "VBNET.ATG" |
|
out val); |
|
|
|
#line 2476 "VBNET.ATG" |
|
expr = new AssignmentExpression(expr, op, val); |
|
} else if (la.kind == 1 || la.kind == 13 || la.kind == 85) { |
|
|
|
#line 2477 "VBNET.ATG" |
|
if (mustBeAssignment) Error("error in assignment."); |
|
} else SynErr(251); |
|
|
|
#line 2480 "VBNET.ATG" |
|
// a field reference expression that stands alone is a |
|
// invocation expression without parantheses and arguments |
|
if(expr is FieldReferenceExpression || expr is IdentifierExpression) { |
|
expr = new InvocationExpression(expr); |
|
} |
|
statement = new StatementExpression(expr); |
|
|
|
break; |
|
} |
|
case 55: { |
|
lexer.NextToken(); |
|
UnaryExpr( |
|
#line 2487 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 2487 "VBNET.ATG" |
|
statement = new StatementExpression(expr); |
|
break; |
|
} |
|
case 188: { |
|
lexer.NextToken(); |
|
Identifier(); |
|
|
|
#line 2489 "VBNET.ATG" |
|
string resourcename = t.val, typeName; |
|
Statement resourceAquisition = null, block = null; |
|
|
|
Expect(47); |
|
if (la.kind == 126) { |
|
lexer.NextToken(); |
|
Qualident( |
|
#line 2493 "VBNET.ATG" |
|
out typeName); |
|
|
|
#line 2493 "VBNET.ATG" |
|
ArrayList initializer = null; |
|
if (la.kind == 23) { |
|
lexer.NextToken(); |
|
if (StartOf(18)) { |
|
ArgumentList( |
|
#line 2493 "VBNET.ATG" |
|
out initializer); |
|
} |
|
Expect(24); |
|
} |
|
|
|
#line 2495 "VBNET.ATG" |
|
resourceAquisition = new LocalVariableDeclaration(new VariableDeclaration(resourcename, new ArrayInitializerExpression(initializer), new TypeReference(typeName))); |
|
|
|
|
|
} else if (StartOf(10)) { |
|
Qualident( |
|
#line 2498 "VBNET.ATG" |
|
out typeName); |
|
Expect(11); |
|
Expr( |
|
#line 2498 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 2500 "VBNET.ATG" |
|
resourceAquisition = new LocalVariableDeclaration(new VariableDeclaration(resourcename, expr, new TypeReference(typeName))); |
|
|
|
} else SynErr(252); |
|
Block( |
|
#line 2503 "VBNET.ATG" |
|
out block); |
|
Expect(87); |
|
Expect(188); |
|
|
|
#line 2505 "VBNET.ATG" |
|
statement = new UsingStatement(resourceAquisition, block); |
|
break; |
|
} |
|
default: SynErr(253); break; |
|
} |
|
} |
|
|
|
void LocalDeclarationStatement( |
|
#line 2213 "VBNET.ATG" |
|
out Statement statement) { |
|
|
|
#line 2215 "VBNET.ATG" |
|
Modifiers m = new Modifiers(); |
|
LocalVariableDeclaration localVariableDeclaration; |
|
bool dimfound = false; |
|
|
|
while (la.kind == 70 || la.kind == 80 || la.kind == 161) { |
|
if (la.kind == 70) { |
|
lexer.NextToken(); |
|
|
|
#line 2221 "VBNET.ATG" |
|
m.Add(Modifier.Const, t.Location); |
|
} else if (la.kind == 161) { |
|
lexer.NextToken(); |
|
|
|
#line 2222 "VBNET.ATG" |
|
m.Add(Modifier.Static, t.Location); |
|
} else { |
|
lexer.NextToken(); |
|
|
|
#line 2223 "VBNET.ATG" |
|
dimfound = true; |
|
} |
|
} |
|
|
|
#line 2226 "VBNET.ATG" |
|
if(dimfound && (m.Modifier & Modifier.Const) != 0) { |
|
Error("Dim is not allowed on constants."); |
|
} |
|
|
|
if(m.isNone && dimfound == false) { |
|
Error("Const, Dim or Static expected"); |
|
} |
|
|
|
localVariableDeclaration = new LocalVariableDeclaration(m.Modifier); |
|
localVariableDeclaration.StartLocation = t.Location; |
|
|
|
VariableDeclarator( |
|
#line 2237 "VBNET.ATG" |
|
localVariableDeclaration.Variables); |
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
VariableDeclarator( |
|
#line 2238 "VBNET.ATG" |
|
localVariableDeclaration.Variables); |
|
} |
|
|
|
#line 2240 "VBNET.ATG" |
|
statement = localVariableDeclaration; |
|
|
|
} |
|
|
|
void TryStatement( |
|
#line 2698 "VBNET.ATG" |
|
out Statement tryStatement) { |
|
|
|
#line 2700 "VBNET.ATG" |
|
Statement blockStmt = null, finallyStmt = null;ArrayList catchClauses = null; |
|
|
|
Expect(174); |
|
EndOfStmt(); |
|
Block( |
|
#line 2703 "VBNET.ATG" |
|
out blockStmt); |
|
if (la.kind == 57 || la.kind == 87 || la.kind == 96) { |
|
CatchClauses( |
|
#line 2704 "VBNET.ATG" |
|
out catchClauses); |
|
} |
|
if (la.kind == 96) { |
|
lexer.NextToken(); |
|
EndOfStmt(); |
|
Block( |
|
#line 2705 "VBNET.ATG" |
|
out finallyStmt); |
|
} |
|
Expect(87); |
|
Expect(174); |
|
|
|
#line 2708 "VBNET.ATG" |
|
tryStatement = new TryCatchStatement(blockStmt, catchClauses, finallyStmt); |
|
|
|
} |
|
|
|
void WithStatement( |
|
#line 2676 "VBNET.ATG" |
|
out Statement withStatement) { |
|
|
|
#line 2678 "VBNET.ATG" |
|
Statement blockStmt = null; |
|
Expression expr = null; |
|
|
|
Expect(182); |
|
|
|
#line 2681 "VBNET.ATG" |
|
Point start = t.Location; |
|
Expr( |
|
#line 2682 "VBNET.ATG" |
|
out expr); |
|
EndOfStmt(); |
|
|
|
#line 2684 "VBNET.ATG" |
|
withStatement = new WithStatement(expr); |
|
withStatement.StartLocation = start; |
|
withStatements.Push(withStatement); |
|
|
|
Block( |
|
#line 2688 "VBNET.ATG" |
|
out blockStmt); |
|
|
|
#line 2690 "VBNET.ATG" |
|
((WithStatement)withStatement).Body = (BlockStatement)blockStmt; |
|
withStatements.Pop(); |
|
|
|
Expect(87); |
|
Expect(182); |
|
|
|
#line 2694 "VBNET.ATG" |
|
withStatement.EndLocation = t.Location; |
|
} |
|
|
|
void WhileOrUntil( |
|
#line 2669 "VBNET.ATG" |
|
out ConditionType conditionType) { |
|
|
|
#line 2670 "VBNET.ATG" |
|
conditionType = ConditionType.None; |
|
if (la.kind == 181) { |
|
lexer.NextToken(); |
|
|
|
#line 2671 "VBNET.ATG" |
|
conditionType = ConditionType.While; |
|
} else if (la.kind == 177) { |
|
lexer.NextToken(); |
|
|
|
#line 2672 "VBNET.ATG" |
|
conditionType = ConditionType.Until; |
|
} else SynErr(254); |
|
} |
|
|
|
void LoopControlVariable( |
|
#line 2510 "VBNET.ATG" |
|
out TypeReference type, out string name) { |
|
|
|
#line 2511 "VBNET.ATG" |
|
ArrayList arrayModifiers = null; |
|
type = null; |
|
|
|
Qualident( |
|
#line 2515 "VBNET.ATG" |
|
out name); |
|
if ( |
|
#line 2516 "VBNET.ATG" |
|
IsDims()) { |
|
ArrayTypeModifiers( |
|
#line 2516 "VBNET.ATG" |
|
out arrayModifiers); |
|
} |
|
if (la.kind == 47) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 2517 "VBNET.ATG" |
|
out type); |
|
|
|
#line 2517 "VBNET.ATG" |
|
if (name.IndexOf('.') > 0) { Error("No type def for 'for each' member indexer allowed."); } |
|
} |
|
|
|
#line 2519 "VBNET.ATG" |
|
if (type != null) { |
|
if(type.RankSpecifier != null && arrayModifiers != null) { |
|
Error("array rank only allowed one time"); |
|
} else if (arrayModifiers != null) { |
|
type.RankSpecifier = (int[])arrayModifiers.ToArray(typeof(int)); |
|
} |
|
} else { |
|
if (arrayModifiers != null) { |
|
type = new TypeReference("Integer", (int[])arrayModifiers.ToArray(typeof(int))); |
|
} else { |
|
type = new TypeReference("Integer"); |
|
} |
|
} |
|
|
|
} |
|
|
|
void CaseClauses( |
|
#line 2629 "VBNET.ATG" |
|
out ArrayList caseClauses) { |
|
|
|
#line 2631 "VBNET.ATG" |
|
caseClauses = new ArrayList(); |
|
CaseLabel caseClause = null; |
|
|
|
CaseClause( |
|
#line 2634 "VBNET.ATG" |
|
out caseClause); |
|
|
|
#line 2634 "VBNET.ATG" |
|
caseClauses.Add(caseClause); |
|
while (la.kind == 12) { |
|
lexer.NextToken(); |
|
CaseClause( |
|
#line 2635 "VBNET.ATG" |
|
out caseClause); |
|
|
|
#line 2635 "VBNET.ATG" |
|
caseClauses.Add(caseClause); |
|
} |
|
} |
|
|
|
void OnErrorStatement( |
|
#line 2536 "VBNET.ATG" |
|
out OnErrorStatement stmt) { |
|
|
|
#line 2538 "VBNET.ATG" |
|
stmt = null; |
|
GotoStatement goToStatement = null; |
|
|
|
Expect(134); |
|
Expect(91); |
|
if ( |
|
#line 2544 "VBNET.ATG" |
|
IsNegativeLabelName()) { |
|
Expect(103); |
|
Expect(15); |
|
Expect(5); |
|
|
|
#line 2546 "VBNET.ATG" |
|
long intLabel = Int64.Parse(t.val); |
|
if(intLabel != 1) { |
|
Error("invalid label in on error statement."); |
|
} |
|
stmt = new OnErrorStatement(new GotoStatement((intLabel * -1).ToString())); |
|
|
|
} else if (la.kind == 103) { |
|
GotoStatement( |
|
#line 2552 "VBNET.ATG" |
|
out goToStatement); |
|
|
|
#line 2554 "VBNET.ATG" |
|
string val = goToStatement.Label; |
|
|
|
// if value is numeric, make sure that is 0 |
|
try { |
|
long intLabel = Int64.Parse(val); |
|
if(intLabel != 0) { |
|
Error("invalid label in on error statement."); |
|
} |
|
} catch { |
|
} |
|
stmt = new OnErrorStatement(goToStatement); |
|
|
|
} else if (la.kind == 153) { |
|
lexer.NextToken(); |
|
Expect(127); |
|
|
|
#line 2568 "VBNET.ATG" |
|
stmt = new OnErrorStatement(new ResumeStatement(true)); |
|
|
|
} else SynErr(255); |
|
} |
|
|
|
void GotoStatement( |
|
#line 2574 "VBNET.ATG" |
|
out ICSharpCode.NRefactory.Parser.AST.GotoStatement goToStatement) { |
|
|
|
#line 2576 "VBNET.ATG" |
|
string label = String.Empty; |
|
|
|
Expect(103); |
|
LabelName( |
|
#line 2579 "VBNET.ATG" |
|
out label); |
|
|
|
#line 2581 "VBNET.ATG" |
|
goToStatement = new ICSharpCode.NRefactory.Parser.AST.GotoStatement(label); |
|
|
|
} |
|
|
|
void ResumeStatement( |
|
#line 2618 "VBNET.ATG" |
|
out ResumeStatement resumeStatement) { |
|
|
|
#line 2620 "VBNET.ATG" |
|
resumeStatement = null; |
|
string label = String.Empty; |
|
|
|
if ( |
|
#line 2623 "VBNET.ATG" |
|
IsResumeNext()) { |
|
Expect(153); |
|
Expect(127); |
|
|
|
#line 2624 "VBNET.ATG" |
|
resumeStatement = new ResumeStatement(true); |
|
} else if (la.kind == 153) { |
|
lexer.NextToken(); |
|
if (StartOf(32)) { |
|
LabelName( |
|
#line 2625 "VBNET.ATG" |
|
out label); |
|
} |
|
|
|
#line 2625 "VBNET.ATG" |
|
resumeStatement = new ResumeStatement(label); |
|
} else SynErr(256); |
|
} |
|
|
|
void CaseClause( |
|
#line 2639 "VBNET.ATG" |
|
out CaseLabel caseClause) { |
|
|
|
#line 2641 "VBNET.ATG" |
|
Expression expr = null; |
|
Expression sexpr = null; |
|
BinaryOperatorType op = BinaryOperatorType.None; |
|
caseClause = null; |
|
|
|
if (la.kind == 85) { |
|
lexer.NextToken(); |
|
|
|
#line 2647 "VBNET.ATG" |
|
caseClause = new CaseLabel(); |
|
} else if (StartOf(33)) { |
|
if (la.kind == 112) { |
|
lexer.NextToken(); |
|
} |
|
switch (la.kind) { |
|
case 26: { |
|
lexer.NextToken(); |
|
|
|
#line 2651 "VBNET.ATG" |
|
op = BinaryOperatorType.LessThan; |
|
break; |
|
} |
|
case 25: { |
|
lexer.NextToken(); |
|
|
|
#line 2652 "VBNET.ATG" |
|
op = BinaryOperatorType.GreaterThan; |
|
break; |
|
} |
|
case 29: { |
|
lexer.NextToken(); |
|
|
|
#line 2653 "VBNET.ATG" |
|
op = BinaryOperatorType.LessThanOrEqual; |
|
break; |
|
} |
|
case 28: { |
|
lexer.NextToken(); |
|
|
|
#line 2654 "VBNET.ATG" |
|
op = BinaryOperatorType.GreaterThanOrEqual; |
|
break; |
|
} |
|
case 11: { |
|
lexer.NextToken(); |
|
|
|
#line 2655 "VBNET.ATG" |
|
op = BinaryOperatorType.Equality; |
|
break; |
|
} |
|
case 27: { |
|
lexer.NextToken(); |
|
|
|
#line 2656 "VBNET.ATG" |
|
op = BinaryOperatorType.InEquality; |
|
break; |
|
} |
|
default: SynErr(257); break; |
|
} |
|
Expr( |
|
#line 2658 "VBNET.ATG" |
|
out expr); |
|
|
|
#line 2660 "VBNET.ATG" |
|
caseClause = new CaseLabel(op, expr); |
|
|
|
} else if (StartOf(19)) { |
|
Expr( |
|
#line 2662 "VBNET.ATG" |
|
out expr); |
|
if (la.kind == 172) { |
|
lexer.NextToken(); |
|
Expr( |
|
#line 2662 "VBNET.ATG" |
|
out sexpr); |
|
} |
|
|
|
#line 2664 "VBNET.ATG" |
|
caseClause = new CaseLabel(expr, sexpr); |
|
|
|
} else SynErr(258); |
|
} |
|
|
|
void CatchClauses( |
|
#line 2713 "VBNET.ATG" |
|
out ArrayList catchClauses) { |
|
|
|
#line 2715 "VBNET.ATG" |
|
catchClauses = new ArrayList(); |
|
TypeReference type = null; |
|
Statement blockStmt = null; |
|
Expression expr = null; |
|
string name = String.Empty; |
|
|
|
while (la.kind == 57) { |
|
lexer.NextToken(); |
|
if (StartOf(10)) { |
|
Identifier(); |
|
|
|
#line 2723 "VBNET.ATG" |
|
name = t.val; |
|
if (la.kind == 47) { |
|
lexer.NextToken(); |
|
TypeName( |
|
#line 2723 "VBNET.ATG" |
|
out type); |
|
} |
|
} |
|
if (la.kind == 180) { |
|
lexer.NextToken(); |
|
Expr( |
|
#line 2724 "VBNET.ATG" |
|
out expr); |
|
} |
|
EndOfStmt(); |
|
Block( |
|
#line 2726 "VBNET.ATG" |
|
out blockStmt); |
|
|
|
#line 2727 "VBNET.ATG" |
|
catchClauses.Add(new CatchClause(type, name, blockStmt, expr)); |
|
} |
|
} |
|
|
|
|
|
public Parser(ILexer lexer) : base(lexer) |
|
{ |
|
} |
|
|
|
public override void Parse() |
|
{ |
|
VBNET(); |
|
|
|
} |
|
|
|
protected void ExpectWeak(int n, int follow) |
|
{ |
|
if (lexer.LookAhead.kind == n) { |
|
lexer.NextToken(); |
|
} else { |
|
SynErr(n); |
|
while (!StartOf(follow)) { |
|
lexer.NextToken(); |
|
} |
|
} |
|
} |
|
|
|
protected bool WeakSeparator(int n, int syFol, int repFol) |
|
{ |
|
bool[] s = new bool[maxT + 1]; |
|
|
|
if (lexer.LookAhead.kind == n) { |
|
lexer.NextToken(); |
|
return true; |
|
} else if (StartOf(repFol)) { |
|
return false; |
|
} else { |
|
for (int i = 0; i <= maxT; i++) { |
|
s[i] = set[syFol, i] || set[repFol, i] || set[0, i]; |
|
} |
|
SynErr(n); |
|
while (!s[lexer.LookAhead.kind]) { |
|
lexer.NextToken(); |
|
} |
|
return StartOf(syFol); |
|
} |
|
} |
|
|
|
protected override void SynErr(int line, int col, int errorNumber) |
|
{ |
|
errors.count++; |
|
string s; |
|
switch (errorNumber) { |
|
case 0: s = "EOF expected"; break; |
|
case 1: s = "EOL expected"; break; |
|
case 2: s = "ident expected"; break; |
|
case 3: s = "LiteralString expected"; break; |
|
case 4: s = "LiteralCharacter expected"; break; |
|
case 5: s = "LiteralInteger expected"; break; |
|
case 6: s = "LiteralDouble expected"; break; |
|
case 7: s = "LiteralSingle expected"; break; |
|
case 8: s = "LiteralDecimal expected"; break; |
|
case 9: s = "LiteralDate expected"; break; |
|
case 10: s = "\".\" expected"; break; |
|
case 11: s = "\"=\" expected"; break; |
|
case 12: s = "\",\" expected"; break; |
|
case 13: s = "\":\" expected"; break; |
|
case 14: s = "\"+\" expected"; break; |
|
case 15: s = "\"-\" expected"; break; |
|
case 16: s = "\"*\" expected"; break; |
|
case 17: s = "\"/\" expected"; break; |
|
case 18: s = "\"\\\\\" expected"; break; |
|
case 19: s = "\"&\" expected"; break; |
|
case 20: s = "\"^\" expected"; break; |
|
case 21: s = "\"{\" expected"; break; |
|
case 22: s = "\"}\" expected"; break; |
|
case 23: s = "\"(\" expected"; break; |
|
case 24: s = "\")\" expected"; break; |
|
case 25: s = "\">\" expected"; break; |
|
case 26: s = "\"<\" expected"; break; |
|
case 27: s = "\"<>\" expected"; break; |
|
case 28: s = "\">=\" expected"; break; |
|
case 29: s = "\"<=\" expected"; break; |
|
case 30: s = "\"<<\" expected"; break; |
|
case 31: s = "\">>\" expected"; break; |
|
case 32: s = "\"+=\" expected"; break; |
|
case 33: s = "\"^=\" expected"; break; |
|
case 34: s = "\"-=\" expected"; break; |
|
case 35: s = "\"*=\" expected"; break; |
|
case 36: s = "\"/=\" expected"; break; |
|
case 37: s = "\"\\\\=\" expected"; break; |
|
case 38: s = "\"<<=\" expected"; break; |
|
case 39: s = "\">>=\" expected"; break; |
|
case 40: s = "\"&=\" expected"; break; |
|
case 41: s = "\"AddHandler\" expected"; break; |
|
case 42: s = "\"AddressOf\" expected"; break; |
|
case 43: s = "\"Alias\" expected"; break; |
|
case 44: s = "\"And\" expected"; break; |
|
case 45: s = "\"AndAlso\" expected"; break; |
|
case 46: s = "\"Ansi\" expected"; break; |
|
case 47: s = "\"As\" expected"; break; |
|
case 48: s = "\"Assembly\" expected"; break; |
|
case 49: s = "\"Auto\" expected"; break; |
|
case 50: s = "\"Binary\" expected"; break; |
|
case 51: s = "\"Boolean\" expected"; break; |
|
case 52: s = "\"ByRef\" expected"; break; |
|
case 53: s = "\"Byte\" expected"; break; |
|
case 54: s = "\"ByVal\" expected"; break; |
|
case 55: s = "\"Call\" expected"; break; |
|
case 56: s = "\"Case\" expected"; break; |
|
case 57: s = "\"Catch\" expected"; break; |
|
case 58: s = "\"CBool\" expected"; break; |
|
case 59: s = "\"CByte\" expected"; break; |
|
case 60: s = "\"CChar\" expected"; break; |
|
case 61: s = "\"CDate\" expected"; break; |
|
case 62: s = "\"CDbl\" expected"; break; |
|
case 63: s = "\"CDec\" expected"; break; |
|
case 64: s = "\"Char\" expected"; break; |
|
case 65: s = "\"CInt\" expected"; break; |
|
case 66: s = "\"Class\" expected"; break; |
|
case 67: s = "\"CLng\" expected"; break; |
|
case 68: s = "\"CObj\" expected"; break; |
|
case 69: s = "\"Compare\" expected"; break; |
|
case 70: s = "\"Const\" expected"; break; |
|
case 71: s = "\"CShort\" expected"; break; |
|
case 72: s = "\"CSng\" expected"; break; |
|
case 73: s = "\"CStr\" expected"; break; |
|
case 74: s = "\"CType\" expected"; break; |
|
case 75: s = "\"Date\" expected"; break; |
|
case 76: s = "\"Decimal\" expected"; break; |
|
case 77: s = "\"Declare\" expected"; break; |
|
case 78: s = "\"Default\" expected"; break; |
|
case 79: s = "\"Delegate\" expected"; break; |
|
case 80: s = "\"Dim\" expected"; break; |
|
case 81: s = "\"DirectCast\" expected"; break; |
|
case 82: s = "\"Do\" expected"; break; |
|
case 83: s = "\"Double\" expected"; break; |
|
case 84: s = "\"Each\" expected"; break; |
|
case 85: s = "\"Else\" expected"; break; |
|
case 86: s = "\"ElseIf\" expected"; break; |
|
case 87: s = "\"End\" expected"; break; |
|
case 88: s = "\"EndIf\" expected"; break; |
|
case 89: s = "\"Enum\" expected"; break; |
|
case 90: s = "\"Erase\" expected"; break; |
|
case 91: s = "\"Error\" expected"; break; |
|
case 92: s = "\"Event\" expected"; break; |
|
case 93: s = "\"Exit\" expected"; break; |
|
case 94: s = "\"Explicit\" expected"; break; |
|
case 95: s = "\"False\" expected"; break; |
|
case 96: s = "\"Finally\" expected"; break; |
|
case 97: s = "\"For\" expected"; break; |
|
case 98: s = "\"Friend\" expected"; break; |
|
case 99: s = "\"Function\" expected"; break; |
|
case 100: s = "\"Get\" expected"; break; |
|
case 101: s = "\"GetType\" expected"; break; |
|
case 102: s = "\"GoSub\" expected"; break; |
|
case 103: s = "\"GoTo\" expected"; break; |
|
case 104: s = "\"Handles\" expected"; break; |
|
case 105: s = "\"If\" expected"; break; |
|
case 106: s = "\"Implements\" expected"; break; |
|
case 107: s = "\"Imports\" expected"; break; |
|
case 108: s = "\"In\" expected"; break; |
|
case 109: s = "\"Inherits\" expected"; break; |
|
case 110: s = "\"Integer\" expected"; break; |
|
case 111: s = "\"Interface\" expected"; break; |
|
case 112: s = "\"Is\" expected"; break; |
|
case 113: s = "\"Let\" expected"; break; |
|
case 114: s = "\"Lib\" expected"; break; |
|
case 115: s = "\"Like\" expected"; break; |
|
case 116: s = "\"Long\" expected"; break; |
|
case 117: s = "\"Loop\" expected"; break; |
|
case 118: s = "\"Me\" expected"; break; |
|
case 119: s = "\"Mod\" expected"; break; |
|
case 120: s = "\"Module\" expected"; break; |
|
case 121: s = "\"MustInherit\" expected"; break; |
|
case 122: s = "\"MustOverride\" expected"; break; |
|
case 123: s = "\"MyBase\" expected"; break; |
|
case 124: s = "\"MyClass\" expected"; break; |
|
case 125: s = "\"Namespace\" expected"; break; |
|
case 126: s = "\"New\" expected"; break; |
|
case 127: s = "\"Next\" expected"; break; |
|
case 128: s = "\"Not\" expected"; break; |
|
case 129: s = "\"Nothing\" expected"; break; |
|
case 130: s = "\"NotInheritable\" expected"; break; |
|
case 131: s = "\"NotOverridable\" expected"; break; |
|
case 132: s = "\"Object\" expected"; break; |
|
case 133: s = "\"Off\" expected"; break; |
|
case 134: s = "\"On\" expected"; break; |
|
case 135: s = "\"Option\" expected"; break; |
|
case 136: s = "\"Optional\" expected"; break; |
|
case 137: s = "\"Or\" expected"; break; |
|
case 138: s = "\"OrElse\" expected"; break; |
|
case 139: s = "\"Overloads\" expected"; break; |
|
case 140: s = "\"Overridable\" expected"; break; |
|
case 141: s = "\"Override\" expected"; break; |
|
case 142: s = "\"Overrides\" expected"; break; |
|
case 143: s = "\"ParamArray\" expected"; break; |
|
case 144: s = "\"Preserve\" expected"; break; |
|
case 145: s = "\"Private\" expected"; break; |
|
case 146: s = "\"Property\" expected"; break; |
|
case 147: s = "\"Protected\" expected"; break; |
|
case 148: s = "\"Public\" expected"; break; |
|
case 149: s = "\"RaiseEvent\" expected"; break; |
|
case 150: s = "\"ReadOnly\" expected"; break; |
|
case 151: s = "\"ReDim\" expected"; break; |
|
case 152: s = "\"RemoveHandler\" expected"; break; |
|
case 153: s = "\"Resume\" expected"; break; |
|
case 154: s = "\"Return\" expected"; break; |
|
case 155: s = "\"Select\" expected"; break; |
|
case 156: s = "\"Set\" expected"; break; |
|
case 157: s = "\"Shadows\" expected"; break; |
|
case 158: s = "\"Shared\" expected"; break; |
|
case 159: s = "\"Short\" expected"; break; |
|
case 160: s = "\"Single\" expected"; break; |
|
case 161: s = "\"Static\" expected"; break; |
|
case 162: s = "\"Step\" expected"; break; |
|
case 163: s = "\"Stop\" expected"; break; |
|
case 164: s = "\"Strict\" expected"; break; |
|
case 165: s = "\"String\" expected"; break; |
|
case 166: s = "\"Structure\" expected"; break; |
|
case 167: s = "\"Sub\" expected"; break; |
|
case 168: s = "\"SyncLock\" expected"; break; |
|
case 169: s = "\"Text\" expected"; break; |
|
case 170: s = "\"Then\" expected"; break; |
|
case 171: s = "\"Throw\" expected"; break; |
|
case 172: s = "\"To\" expected"; break; |
|
case 173: s = "\"True\" expected"; break; |
|
case 174: s = "\"Try\" expected"; break; |
|
case 175: s = "\"TypeOf\" expected"; break; |
|
case 176: s = "\"Unicode\" expected"; break; |
|
case 177: s = "\"Until\" expected"; break; |
|
case 178: s = "\"Variant\" expected"; break; |
|
case 179: s = "\"Wend\" expected"; break; |
|
case 180: s = "\"When\" expected"; break; |
|
case 181: s = "\"While\" expected"; break; |
|
case 182: s = "\"With\" expected"; break; |
|
case 183: s = "\"WithEvents\" expected"; break; |
|
case 184: s = "\"WriteOnly\" expected"; break; |
|
case 185: s = "\"Xor\" expected"; break; |
|
case 186: s = "\"Continue\" expected"; break; |
|
case 187: s = "\"Operator\" expected"; break; |
|
case 188: s = "\"Using\" expected"; break; |
|
case 189: s = "\"IsNot\" expected"; break; |
|
case 190: s = "\"SByte\" expected"; break; |
|
case 191: s = "\"UInteger\" expected"; break; |
|
case 192: s = "\"ULong\" expected"; break; |
|
case 193: s = "\"UShort\" expected"; break; |
|
case 194: s = "\"Global\" expected"; break; |
|
case 195: s = "\"TryCast\" expected"; break; |
|
case 196: s = "\"Of\" expected"; break; |
|
case 197: s = "\"Narrowing\" expected"; break; |
|
case 198: s = "\"Widening\" expected"; break; |
|
case 199: s = "\"Partial\" expected"; break; |
|
case 200: s = "\"Custom\" expected"; break; |
|
case 201: s = "??? expected"; break; |
|
case 202: s = "invalid OptionStmt"; break; |
|
case 203: s = "invalid OptionStmt"; break; |
|
case 204: s = "invalid GlobalAttributeSection"; break; |
|
case 205: s = "invalid GlobalAttributeSection"; break; |
|
case 206: s = "invalid NamespaceMemberDecl"; break; |
|
case 207: s = "invalid OptionValue"; break; |
|
case 208: s = "invalid EndOfStmt"; break; |
|
case 209: s = "invalid TypeModifier"; break; |
|
case 210: s = "invalid NonModuleDeclaration"; break; |
|
case 211: s = "invalid NonModuleDeclaration"; break; |
|
case 212: s = "invalid Identifier"; break; |
|
case 213: s = "invalid TypeParameterConstraints"; break; |
|
case 214: s = "invalid PrimitiveTypeName"; break; |
|
case 215: s = "invalid MemberModifier"; break; |
|
case 216: s = "invalid StructureMemberDecl"; break; |
|
case 217: s = "invalid StructureMemberDecl"; break; |
|
case 218: s = "invalid StructureMemberDecl"; break; |
|
case 219: s = "invalid StructureMemberDecl"; break; |
|
case 220: s = "invalid StructureMemberDecl"; break; |
|
case 221: s = "invalid StructureMemberDecl"; break; |
|
case 222: s = "invalid StructureMemberDecl"; break; |
|
case 223: s = "invalid InterfaceMemberDecl"; break; |
|
case 224: s = "invalid InterfaceMemberDecl"; break; |
|
case 225: s = "invalid Charset"; break; |
|
case 226: s = "invalid VariableDeclarator"; break; |
|
case 227: s = "invalid AccessorDecls"; break; |
|
case 228: s = "invalid EventAccessorDeclaration"; break; |
|
case 229: s = "invalid OverloadableOperator"; break; |
|
case 230: s = "invalid VariableInitializer"; break; |
|
case 231: s = "invalid EventMemberSpecifier"; break; |
|
case 232: s = "invalid EventMemberSpecifier"; break; |
|
case 233: s = "invalid SimpleExpr"; break; |
|
case 234: s = "invalid SimpleExpr"; break; |
|
case 235: s = "invalid SimpleExpr"; break; |
|
case 236: s = "invalid AssignmentOperator"; break; |
|
case 237: s = "invalid IdentifierOrKeyword"; break; |
|
case 238: s = "invalid CastTarget"; break; |
|
case 239: s = "invalid Argument"; break; |
|
case 240: s = "invalid RelationalExpr"; break; |
|
case 241: s = "invalid RelationalExpr"; break; |
|
case 242: s = "invalid NonArrayTypeName"; break; |
|
case 243: s = "invalid AttributeArguments"; break; |
|
case 244: s = "invalid ParameterModifier"; break; |
|
case 245: s = "invalid Statement"; break; |
|
case 246: s = "invalid LabelName"; break; |
|
case 247: s = "invalid EmbeddedStatement"; break; |
|
case 248: s = "invalid EmbeddedStatement"; break; |
|
case 249: s = "invalid EmbeddedStatement"; break; |
|
case 250: s = "invalid EmbeddedStatement"; break; |
|
case 251: s = "invalid EmbeddedStatement"; break; |
|
case 252: s = "invalid EmbeddedStatement"; break; |
|
case 253: s = "invalid EmbeddedStatement"; break; |
|
case 254: s = "invalid WhileOrUntil"; break; |
|
case 255: s = "invalid OnErrorStatement"; break; |
|
case 256: s = "invalid ResumeStatement"; break; |
|
case 257: s = "invalid CaseClause"; break; |
|
case 258: s = "invalid CaseClause"; break; |
|
|
|
default: s = "error " + errorNumber; break; |
|
} |
|
errors.Error(line, col, s); |
|
} |
|
|
|
protected bool StartOf(int s) |
|
{ |
|
return set[s, lexer.LookAhead.kind]; |
|
} |
|
|
|
static bool[,] set = { |
|
{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x}, |
|
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, T,T,x,x, x,T,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, T,x,x,x, x,x,x,x, x,T,T,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x}, |
|
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, T,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, T,x,x,x, x,x,x,x, x,T,T,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x}, |
|
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, T,x,x,x, x,x,x,x, x,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x}, |
|
{x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x}, |
|
{x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, x,T,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,T,x,x, x,x,x,T, T,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,T,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,x, x,x,x,x, x,x,x}, |
|
{x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,T,T,x, x,x,x,x, x,T,T,T, T,x,x,x, x,x,x,x, x,T,x,x, T,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, T,T,T,x, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,T, T,x,T,x, x,T,T,T, T,x,T,x, x,x,x,x, x,T,T,x, x,x,x,x, x,x,T,T, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,T, x,x,x,x, x,x,x,x, x,T,T,T, T,x,x}, |
|
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,T, T,x,T,x, x,T,x,T, T,x,T,x, x,x,x,x, x,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,x,x}, |
|
{x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x}, |
|
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,T,x,x, T,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, T,T,T,x, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,T, T,x,T,x, x,T,T,T, T,x,T,x, x,x,x,x, x,T,T,x, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,T,T,T, x,x,x}, |
|
{x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x}, |
|
{x,T,T,T, T,T,T,T, T,T,T,x, x,T,T,T, T,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,x,x,x, x,x,T,T, x,T,x,T, x,x,T,T, T,T,T,T, T,T,x,T, T,T,T,T, T,T,T,T, T,x,x,x, T,T,T,T, x,x,x,T, x,x,T,T, x,T,x,T, x,T,x,x, x,T,x,T, x,T,x,x, x,x,T,x, x,x,x,x, T,x,T,x, x,x,x,T, T,x,T,x, x,T,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, T,T,T,T, x,x,x,T, T,T,x,T, x,T,x,x, T,T,x,T, x,T,T,T, x,x,x,x, x,T,T,x, x,x,T,x, T,x,T,T, T,T,x,T, x,x,x,x, x,x,x}, |
|
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x}, |
|
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x}, |
|
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, T,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,T, T,x,T,x, x,T,T,T, T,x,T,x, x,x,x,x, x,T,T,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,x,x}, |
|
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x}, |
|
{x,T,T,T, T,T,T,T, T,T,T,x, x,T,T,T, T,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,x,x,x, x,x,T,T, x,T,x,T, x,x,T,T, T,T,T,T, T,T,x,T, T,T,T,T, T,T,T,T, T,x,x,x, T,T,T,T, x,x,x,x, x,x,T,T, x,T,x,T, x,T,x,x, x,T,x,T, x,T,x,x, x,x,T,x, x,x,x,x, T,x,T,x, x,x,x,T, T,x,T,x, x,T,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, T,T,T,T, x,x,x,T, T,T,x,T, x,T,x,x, T,T,x,T, x,T,T,T, x,x,x,x, x,T,T,x, x,x,T,x, T,x,T,T, T,T,x,T, x,x,x,x, x,x,x}, |
|
{x,T,x,x, x,x,x,x, x,x,x,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x}, |
|
{x,x,T,T, T,T,T,T, T,T,T,x, x,x,T,T, T,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,T,T, x,T,x,x, x,x,T,T, T,T,T,T, T,T,x,T, T,T,x,T, T,T,T,T, T,x,x,x, x,T,x,T, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, T,x,T,x, x,x,x,T, T,x,T,x, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,T,x,x, x,T,x,x, x,T,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,x,T, x,x,x,x, x,x,x}, |
|
{x,x,T,T, T,T,T,T, T,T,T,x, x,x,T,T, T,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,T,T, x,T,x,x, x,x,T,T, T,T,T,T, T,T,x,T, T,T,x,T, T,T,T,T, T,x,x,x, x,T,x,T, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, T,x,T,x, x,x,x,T, T,x,T,x, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,T,x,x, x,T,x,x, x,T,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,x,T, x,x,x,x, x,x,x}, |
|
{x,x,T,T, T,T,T,T, T,T,T,x, x,x,T,T, T,x,x,x, x,T,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,T,T, x,T,x,x, x,x,T,T, T,T,T,T, T,T,x,T, T,T,x,T, T,T,T,T, T,x,x,x, x,T,x,T, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, T,x,T,x, x,x,x,T, T,x,T,x, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,T,x,x, x,T,x,x, x,T,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,x,T, x,x,x,x, x,x,x}, |
|
{x,x,T,T, T,T,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,T,T, x,T,x,x, x,x,T,T, T,T,T,T, T,T,x,T, T,T,x,T, T,T,T,T, T,x,x,x, x,T,x,T, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, T,x,T,x, x,x,x,T, T,x,T,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,T,x,x, x,T,x,x, x,T,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,x,T, x,x,x,x, x,x,x}, |
|
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,T,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,x,x, x,x,x,x, x,x,x}, |
|
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,T,x,T, T,x,x,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x}, |
|
{x,x,T,T, T,T,T,T, T,T,T,x, T,x,T,T, T,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,T,T, x,T,x,x, x,x,T,T, T,T,T,T, T,T,x,T, T,T,x,T, T,T,T,T, T,x,x,x, x,T,x,T, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, T,x,T,x, x,x,x,T, T,x,T,x, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,T,x,x, x,T,x,x, x,T,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,x,T, x,x,x,x, x,x,x}, |
|
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x}, |
|
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x}, |
|
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,T,T,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x}, |
|
{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x}, |
|
{x,x,T,T, T,T,T,T, T,T,T,x, x,x,T,T, T,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,x,x,x, x,x,T,T, x,T,x,T, x,x,T,T, T,T,T,T, T,T,x,T, T,T,x,T, T,T,T,T, T,x,x,x, x,T,T,T, x,x,x,x, x,x,T,T, x,T,x,T, x,T,x,x, x,T,x,T, x,T,x,x, x,x,T,x, x,x,x,x, T,x,T,x, x,x,x,T, T,x,T,x, x,T,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, T,T,T,T, x,x,x,T, T,x,x,T, x,T,x,x, T,T,x,T, x,T,T,T, x,x,x,x, x,T,T,x, x,x,T,x, T,x,T,T, T,T,x,T, x,x,x,x, x,x,x}, |
|
{x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x}, |
|
{x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,T,T,T, T,T,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x}, |
|
{x,x,T,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x}, |
|
{x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x} |
|
|
|
}; |
|
} // end Parser |
|
|
|
} |