public virtual object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data) {
Debug.Assert((declareDeclaration != null));
Debug.Assert((declareDeclaration.Attributes != null));
Debug.Assert((declareDeclaration.Parameters != null));
Debug.Assert((declareDeclaration.TypeReference != null));
foreach (AttributeSection o in declareDeclaration.Attributes) {
Debug.Assert(o != null);
o.AcceptVisitor(this, data);
}
foreach (ParameterDeclarationExpression o in declareDeclaration.Parameters) {
Debug.Assert(o != null);
o.AcceptVisitor(this, data);
}
return declareDeclaration.TypeReference.AcceptVisitor(this, data);
}
public sealed override object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data) {
this.BeginVisit(declareDeclaration);
object result = this.TrackedVisitDeclareDeclaration(declareDeclaration, data);
this.EndVisit(declareDeclaration);
return result;
}
public virtual object TrackedVisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data) {
return base.VisitDeclareDeclaration(declareDeclaration, data);
}
public override object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data)
{
if (usings != null && !usings.ContainsKey("System.Runtime.InteropServices")) {
UsingDeclaration @using = new UsingDeclaration("System.Runtime.InteropServices");
addedUsings.Add(@using);
base.VisitUsingDeclaration(@using, data);
}
MethodDeclaration method = new MethodDeclaration {
Name = declareDeclaration.Name,
Modifier = declareDeclaration.Modifier,
TypeReference = declareDeclaration.TypeReference,
Parameters = declareDeclaration.Parameters,
Attributes = declareDeclaration.Attributes
};
if ((method.Modifier & Modifiers.Visibility) == 0)
method.Modifier |= Modifiers.Public;
method.Modifier |= Modifiers.Extern | Modifiers.Static;
if (method.TypeReference.IsNull) {
method.TypeReference = new TypeReference("System.Void", true);
}
Attribute att = new Attribute("DllImport", null, null);
att.PositionalArguments.Add(CreateStringLiteral(declareDeclaration.Library));
if (declareDeclaration.Alias.Length > 0) {
att.NamedArguments.Add(new NamedArgumentExpression("EntryPoint", CreateStringLiteral(declareDeclaration.Alias)));
}
switch (declareDeclaration.Charset) {
case CharsetModifier.Auto:
att.NamedArguments.Add(new NamedArgumentExpression("CharSet",
new MemberReferenceExpression(new IdentifierExpression("CharSet"),
"Auto")));
break;
case CharsetModifier.Unicode:
att.NamedArguments.Add(new NamedArgumentExpression("CharSet",
new MemberReferenceExpression(new IdentifierExpression("CharSet"),
"Unicode")));
break;
default:
att.NamedArguments.Add(new NamedArgumentExpression("CharSet",
new MemberReferenceExpression(new IdentifierExpression("CharSet"),
"Ansi")));
break;
}
att.NamedArguments.Add(new NamedArgumentExpression("SetLastError", new PrimitiveExpression(true, true.ToString())));
att.NamedArguments.Add(new NamedArgumentExpression("ExactSpelling", new PrimitiveExpression(true, true.ToString())));
method.Attributes.Add(new AttributeSection { Attributes = { att } });
ReplaceCurrentNode(method);
return base.VisitMethodDeclaration(method, data);
}
bool ConvertPInvoke(MethodDeclaration method, ICSharpCode.OldNRefactory.Ast.Attribute att)
{
if (att.PositionalArguments.Count != 1)
return false;
PrimitiveExpression pe = att.PositionalArguments[0] as PrimitiveExpression;
if (pe == null || !(pe.Value is string))
return false;
string libraryName = (string)pe.Value;
string alias = null;
bool setLastError = false;
bool exactSpelling = false;
CharsetModifier charSet = CharsetModifier.Auto;
foreach (NamedArgumentExpression arg in att.NamedArguments) {
switch (arg.Name) {
case "SetLastError":
pe = arg.Expression as PrimitiveExpression;
if (pe != null && pe.Value is bool)
setLastError = (bool)pe.Value;
else
return false;
break;
case "ExactSpelling":
pe = arg.Expression as PrimitiveExpression;
if (pe != null && pe.Value is bool)
exactSpelling = (bool)pe.Value;
else
return false;
break;
case "CharSet":
{
MemberReferenceExpression fre = arg.Expression as MemberReferenceExpression;
if (fre == null || !(fre.TargetObject is IdentifierExpression))
return false;
if ((fre.TargetObject as IdentifierExpression).Identifier != "CharSet")
return false;
switch (fre.MemberName) {
case "Unicode":
charSet = CharsetModifier.Unicode;
break;
case "Auto":
charSet = CharsetModifier.Auto;
break;
case "Ansi":
charSet = CharsetModifier.Ansi;
break;
default:
return false;
}
}
break;
case "EntryPoint":
pe = arg.Expression as PrimitiveExpression;
if (pe != null)
alias = pe.Value as string;
break;
default:
return false;
}
}
if (setLastError && exactSpelling) {
// Only P/Invokes with SetLastError and ExactSpelling can be converted to a DeclareDeclaration
const Modifiers removeModifiers = Modifiers.Static | Modifiers.Extern;
DeclareDeclaration decl = new DeclareDeclaration(method.Name, method.Modifier &~ removeModifiers,
method.TypeReference,
method.Parameters,
method.Attributes,
libraryName, alias, charSet);
ReplaceCurrentNode(decl);
base.VisitDeclareDeclaration(decl, null);
return true;
} else {
return false;
}
}
void StructureMemberDecl(
#line 775 "VBNET.ATG"
ModifierList m, List<AttributeSection> attributes) {
#line 777 "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 71: case 90: case 102: case 129: case 141: case 194: {
NonModuleDeclaration(
#line 784 "VBNET.ATG"
m, attributes);
break;
}
case 195: {
lexer.NextToken();
#line 788 "VBNET.ATG"
Location startPos = t.Location;
if (StartOf(14)) {
#line 792 "VBNET.ATG"
string name = String.Empty;
MethodDeclaration methodDeclaration; List<string> handlesClause = null;
List<InterfaceImplementation> implementsClause = null;
Identifier();
#line 798 "VBNET.ATG"
name = t.val;
m.Check(Modifiers.VBMethods);
TypeParameterList(
#line 801 "VBNET.ATG"
templates);
if (la.kind == 25) {
lexer.NextToken();
if (StartOf(4)) {
FormalParameterList(
#line 802 "VBNET.ATG"
p);
}
Expect(26);
}
if (la.kind == 121 || la.kind == 123) {
if (la.kind == 123) {
ImplementsClause(
#line 805 "VBNET.ATG"
out implementsClause);
} else {
HandlesClause(
#line 807 "VBNET.ATG"
out handlesClause);
}
}
#line 810 "VBNET.ATG"
Location endLocation = t.EndLocation;
if (
#line 813 "VBNET.ATG"
IsMustOverride(m)) {
EndOfStmt();
#line 816 "VBNET.ATG"
methodDeclaration = new MethodDeclaration {
Name = name, Modifier = m.Modifier, Parameters = p, Attributes = attributes,
StartLocation = m.GetDeclarationLocation(startPos), EndLocation = endLocation,
TypeReference = new TypeReference("System.Void", true),
Templates = templates,
HandlesClause = handlesClause,
InterfaceImplementations = implementsClause
};
compilationUnit.AddChild(methodDeclaration);
} else if (la.kind == 1) {
lexer.NextToken();
#line 829 "VBNET.ATG"
methodDeclaration = new MethodDeclaration {
Name = name, Modifier = m.Modifier, Parameters = p, Attributes = attributes,
StartLocation = m.GetDeclarationLocation(startPos), EndLocation = endLocation,
TypeReference = new TypeReference("System.Void", true),
Templates = templates,
HandlesClause = handlesClause,
InterfaceImplementations = implementsClause
};
compilationUnit.AddChild(methodDeclaration);
#line 840 "VBNET.ATG"
if (ParseMethodBodies) {
Block(
#line 841 "VBNET.ATG"
out stmt);
Expect(100);
Expect(195);
#line 843 "VBNET.ATG"
} else {
// don't parse method body
lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
}
#line 849 "VBNET.ATG"
methodDeclaration.Body = (BlockStatement)stmt;
#line 850 "VBNET.ATG"
methodDeclaration.Body.EndLocation = t.EndLocation;
EndOfStmt();
} else SynErr(238);
} else if (la.kind == 148) {
lexer.NextToken();
if (la.kind == 25) {
lexer.NextToken();
if (StartOf(4)) {
FormalParameterList(
#line 854 "VBNET.ATG"
p);
}
Expect(26);
}
#line 855 "VBNET.ATG"
m.Check(Modifiers.Constructors);
#line 856 "VBNET.ATG"
Location constructorEndLocation = t.EndLocation;
Expect(1);
#line 859 "VBNET.ATG"
if (ParseMethodBodies) {
Block(
#line 860 "VBNET.ATG"
out stmt);
Expect(100);
Expect(195);
#line 862 "VBNET.ATG"
} else {
// don't parse method body
lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
}
#line 868 "VBNET.ATG"
Location endLocation = t.EndLocation;
EndOfStmt();
#line 871 "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(239);
break;
}
case 114: {
lexer.NextToken();
#line 883 "VBNET.ATG"
m.Check(Modifiers.VBMethods);
string name = String.Empty;
Location startPos = t.Location;
MethodDeclaration methodDeclaration;List<string> handlesClause = null;
List<InterfaceImplementation> implementsClause = null;
AttributeSection returnTypeAttributeSection = null;
Identifier();
#line 890 "VBNET.ATG"
name = t.val;
TypeParameterList(
#line 891 "VBNET.ATG"
templates);
if (la.kind == 25) {
lexer.NextToken();
if (StartOf(4)) {
FormalParameterList(
#line 892 "VBNET.ATG"
p);
}
Expect(26);
}
if (la.kind == 50) {
lexer.NextToken();
while (la.kind == 28) {
AttributeSection(
#line 893 "VBNET.ATG"
out returnTypeAttributeSection);
}
TypeName(
#line 893 "VBNET.ATG"
out type);
}
#line 895 "VBNET.ATG"
if(type == null) {
type = new TypeReference("System.Object", true);
}
if (la.kind == 121 || la.kind == 123) {
if (la.kind == 123) {
ImplementsClause(
#line 901 "VBNET.ATG"
out implementsClause);
} else {
HandlesClause(
#line 903 "VBNET.ATG"
out handlesClause);
}
}
if (
#line 908 "VBNET.ATG"
IsMustOverride(m)) {
EndOfStmt();
#line 911 "VBNET.ATG"
methodDeclaration = new MethodDeclaration {
Name = name, Modifier = m.Modifier, TypeReference = type,
Parameters = p, Attributes = attributes,
StartLocation = m.GetDeclarationLocation(startPos),
EndLocation = t.EndLocation,
HandlesClause = handlesClause,
Templates = templates,
InterfaceImplementations = implementsClause
};
if (returnTypeAttributeSection != null) {
returnTypeAttributeSection.AttributeTarget = "return";
methodDeclaration.Attributes.Add(returnTypeAttributeSection);
}
compilationUnit.AddChild(methodDeclaration);
} else if (la.kind == 1) {
lexer.NextToken();
#line 929 "VBNET.ATG"
methodDeclaration = new MethodDeclaration {
Name = name, Modifier = m.Modifier, TypeReference = type,
Parameters = p, Attributes = attributes,
StartLocation = m.GetDeclarationLocation(startPos),
EndLocation = t.EndLocation,
Templates = templates,
HandlesClause = handlesClause,
InterfaceImplementations = implementsClause
};
if (returnTypeAttributeSection != null) {
returnTypeAttributeSection.AttributeTarget = "return";
methodDeclaration.Attributes.Add(returnTypeAttributeSection);
}
compilationUnit.AddChild(methodDeclaration);
if (ParseMethodBodies) {
Block(
#line 946 "VBNET.ATG"
out stmt);
Expect(100);
Expect(114);
#line 948 "VBNET.ATG"
} else {
// don't parse method body
lexer.SkipCurrentBlock(Tokens.Function); stmt = new BlockStatement();
}
methodDeclaration.Body = (BlockStatement)stmt;
methodDeclaration.Body.StartLocation = methodDeclaration.EndLocation;
methodDeclaration.Body.EndLocation = t.EndLocation;
EndOfStmt();
} else SynErr(240);
break;
}
case 88: {
lexer.NextToken();
#line 962 "VBNET.ATG"
m.Check(Modifiers.VBExternalMethods);
Location startPos = t.Location;
CharsetModifier charsetModifer = CharsetModifier.None;
string library = String.Empty;
string alias = null;
string name = String.Empty;
if (StartOf(15)) {
Charset(
#line 969 "VBNET.ATG"
out charsetModifer);
}
if (la.kind == 195) {
lexer.NextToken();
Identifier();
#line 972 "VBNET.ATG"
name = t.val;
Expect(135);
Expect(3);
#line 973 "VBNET.ATG"
library = t.literalValue as string;
if (la.kind == 46) {
lexer.NextToken();
Expect(3);
#line 974 "VBNET.ATG"
alias = t.literalValue as string;
}
if (la.kind == 25) {
lexer.NextToken();
if (StartOf(4)) {
FormalParameterList(
#line 975 "VBNET.ATG"
p);
}
Expect(26);
}
EndOfStmt();
#line 978 "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 == 114) {
lexer.NextToken();
Identifier();
#line 985 "VBNET.ATG"
name = t.val;
Expect(135);
Expect(3);
#line 986 "VBNET.ATG"
library = t.literalValue as string;
if (la.kind == 46) {
lexer.NextToken();
Expect(3);
#line 987 "VBNET.ATG"
alias = t.literalValue as string;
}
if (la.kind == 25) {
lexer.NextToken();
if (StartOf(4)) {
FormalParameterList(
#line 988 "VBNET.ATG"
p);
}
Expect(26);
}
if (la.kind == 50) {
lexer.NextToken();
TypeName(
#line 989 "VBNET.ATG"
out type);
}
EndOfStmt();
#line 992 "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(241);
break;
}
case 106: {
lexer.NextToken();
#line 1002 "VBNET.ATG"
m.Check(Modifiers.VBEvents);
Location startPos = t.Location;
EventDeclaration eventDeclaration;
string name = String.Empty;
List<InterfaceImplementation> implementsClause = null;
Identifier();
#line 1008 "VBNET.ATG"
name= t.val;
if (la.kind == 50) {
lexer.NextToken();
TypeName(
#line 1010 "VBNET.ATG"
out type);
} else if (StartOf(16)) {
if (la.kind == 25) {
lexer.NextToken();
if (StartOf(4)) {
FormalParameterList(
#line 1012 "VBNET.ATG"
p);
}
Expect(26);
}
} else SynErr(242);
if (la.kind == 123) {
ImplementsClause(
#line 1014 "VBNET.ATG"
out implementsClause);
}
#line 1016 "VBNET.ATG"
eventDeclaration = new EventDeclaration {
Name = name, TypeReference = type, Modifier = m.Modifier,
Parameters = p, Attributes = attributes, InterfaceImplementations = implementsClause,
StartLocation = m.GetDeclarationLocation(startPos),
EndLocation = t.EndLocation
};
compilationUnit.AddChild(eventDeclaration);
EndOfStmt();
break;
}
case 2: case 45: case 49: case 51: case 52: case 53: case 54: case 57: case 74: case 91: case 94: case 103: case 108: case 113: case 120: case 126: case 130: case 133: case 156: case 162: case 169: case 188: case 197: case 198: case 208: case 209: case 215: {
#line 1026 "VBNET.ATG"
Location startPos = t.Location;
#line 1028 "VBNET.ATG"
m.Check(Modifiers.Fields);
FieldDeclaration fd = new FieldDeclaration(attributes, null, m.Modifier);
fd.StartLocation = m.GetDeclarationLocation(startPos);
IdentifierForFieldDeclaration();
#line 1032 "VBNET.ATG"
string name = t.val;
VariableDeclaratorPartAfterIdentifier(
#line 1033 "VBNET.ATG"
variableDeclarators, name);
while (la.kind == 12) {
lexer.NextToken();
VariableDeclarator(
#line 1034 "VBNET.ATG"
variableDeclarators);
}
EndOfStmt();
#line 1037 "VBNET.ATG"
fd.EndLocation = t.EndLocation;
fd.Fields = variableDeclarators;
compilationUnit.AddChild(fd);
break;
}
case 75: {
#line 1042 "VBNET.ATG"
m.Check(Modifiers.Fields);
lexer.NextToken();
#line 1043 "VBNET.ATG"
m.Add(Modifiers.Const, t.Location);
#line 1045 "VBNET.ATG"
FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier);
fd.StartLocation = m.GetDeclarationLocation(t.Location);
List<VariableDeclaration> constantDeclarators = new List<VariableDeclaration>();
ConstantDeclarator(
#line 1049 "VBNET.ATG"
constantDeclarators);
while (la.kind == 12) {
lexer.NextToken();
ConstantDeclarator(
#line 1050 "VBNET.ATG"
constantDeclarators);
}
#line 1052 "VBNET.ATG"
fd.Fields = constantDeclarators;
fd.EndLocation = t.Location;
EndOfStmt();
#line 1057 "VBNET.ATG"
fd.EndLocation = t.EndLocation;
compilationUnit.AddChild(fd);
break;
}
case 171: {
lexer.NextToken();
#line 1063 "VBNET.ATG"
m.Check(Modifiers.VBProperties);
Location startPos = t.Location;
List<InterfaceImplementation> implementsClause = null;
Identifier();
#line 1067 "VBNET.ATG"
string propertyName = t.val;
if (la.kind == 25) {
lexer.NextToken();
if (StartOf(4)) {
FormalParameterList(
#line 1068 "VBNET.ATG"
p);
}
Expect(26);
}
if (la.kind == 50) {
lexer.NextToken();
TypeName(
#line 1069 "VBNET.ATG"
out type);
}
#line 1071 "VBNET.ATG"
if(type == null) {
type = new TypeReference("System.Object", true);
}
if (la.kind == 123) {
ImplementsClause(
#line 1075 "VBNET.ATG"
out implementsClause);
}
EndOfStmt();
if (
#line 1079 "VBNET.ATG"
IsMustOverride(m)) {
#line 1081 "VBNET.ATG"
PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
pDecl.StartLocation = m.GetDeclarationLocation(startPos);
pDecl.EndLocation = t.Location;
pDecl.TypeReference = type;
pDecl.InterfaceImplementations = implementsClause;
pDecl.Parameters = p;
compilationUnit.AddChild(pDecl);
} else if (StartOf(17)) {
#line 1091 "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.InterfaceImplementations = implementsClause;
pDecl.Parameters = p;
PropertyGetRegion getRegion;
PropertySetRegion setRegion;
AccessorDecls(
#line 1101 "VBNET.ATG"
out getRegion, out setRegion);
Expect(100);
Expect(171);
EndOfStmt();
#line 1105 "VBNET.ATG"
pDecl.GetRegion = getRegion;
pDecl.SetRegion = setRegion;
pDecl.BodyEnd = t.EndLocation;
compilationUnit.AddChild(pDecl);
} else SynErr(243);
break;
}
case 85: {
lexer.NextToken();
#line 1112 "VBNET.ATG"
Location startPos = t.Location;
Expect(106);
#line 1114 "VBNET.ATG"
m.Check(Modifiers.VBCustomEvents);
EventAddRemoveRegion eventAccessorDeclaration;
EventAddRegion addHandlerAccessorDeclaration = null;
EventRemoveRegion removeHandlerAccessorDeclaration = null;
EventRaiseRegion raiseEventAccessorDeclaration = null;
List<InterfaceImplementation> implementsClause = null;
Identifier();
#line 1121 "VBNET.ATG"
string customEventName = t.val;
Expect(50);
TypeName(
#line 1122 "VBNET.ATG"
out type);
if (la.kind == 123) {
ImplementsClause(
#line 1123 "VBNET.ATG"
out implementsClause);
}
EndOfStmt();
while (StartOf(18)) {
EventAccessorDeclaration(
#line 1126 "VBNET.ATG"
out eventAccessorDeclaration);
#line 1128 "VBNET.ATG"
if(eventAccessorDeclaration is EventAddRegion)
{
addHandlerAccessorDeclaration = (EventAddRegion)eventAccessorDeclaration;
}
else if(eventAccessorDeclaration is EventRemoveRegion)
{
removeHandlerAccessorDeclaration = (EventRemoveRegion)eventAccessorDeclaration;
}
else if(eventAccessorDeclaration is EventRaiseRegion)
{
raiseEventAccessorDeclaration = (EventRaiseRegion)eventAccessorDeclaration;
}
}
Expect(100);
Expect(106);
EndOfStmt();
#line 1144 "VBNET.ATG"
if(addHandlerAccessorDeclaration == null)
{
Error("Need to provide AddHandler accessor.");
}
if(removeHandlerAccessorDeclaration == null)
{
Error("Need to provide RemoveHandler accessor.");
}
if(raiseEventAccessorDeclaration == null)
{
Error("Need to provide RaiseEvent accessor.");
}
EventDeclaration decl = new EventDeclaration {
TypeReference = type, Name = customEventName, Modifier = m.Modifier,
Attributes = attributes,
StartLocation = m.GetDeclarationLocation(startPos),
EndLocation = t.EndLocation,
AddRegion = addHandlerAccessorDeclaration,
RemoveRegion = removeHandlerAccessorDeclaration,
RaiseRegion = raiseEventAccessorDeclaration
};
compilationUnit.AddChild(decl);
break;
}
case 147: case 158: case 217: {
#line 1170 "VBNET.ATG"
ConversionType opConversionType = ConversionType.None;
if (la.kind == 147 || la.kind == 217) {
if (la.kind == 217) {
lexer.NextToken();
#line 1171 "VBNET.ATG"
opConversionType = ConversionType.Implicit;
} else {
lexer.NextToken();
#line 1172 "VBNET.ATG"
opConversionType = ConversionType.Explicit;
}
}
Expect(158);
#line 1175 "VBNET.ATG"
m.Check(Modifiers.VBOperators);
Location 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 1185 "VBNET.ATG"
out operatorType);
Expect(25);
if (la.kind == 59) {
lexer.NextToken();
}
Identifier();
#line 1186 "VBNET.ATG"
operandName = t.val;
if (la.kind == 50) {
lexer.NextToken();
TypeName(
#line 1187 "VBNET.ATG"
out operandType);
}
#line 1188 "VBNET.ATG"
parameters.Add(new ParameterDeclarationExpression(operandType, operandName, ParameterModifiers.In));
while (la.kind == 12) {
lexer.NextToken();
if (la.kind == 59) {
lexer.NextToken();
}
Identifier();
#line 1192 "VBNET.ATG"
operandName = t.val;
if (la.kind == 50) {
lexer.NextToken();
TypeName(
#line 1193 "VBNET.ATG"
out operandType);
}
#line 1194 "VBNET.ATG"
parameters.Add(new ParameterDeclarationExpression(operandType, operandName, ParameterModifiers.In));
}
Expect(26);
#line 1197 "VBNET.ATG"
Location endPos = t.EndLocation;
if (la.kind == 50) {
lexer.NextToken();
while (la.kind == 28) {
AttributeSection(
#line 1198 "VBNET.ATG"
out section);
#line 1198 "VBNET.ATG"
returnTypeAttributes.Add(section);
}
TypeName(
#line 1198 "VBNET.ATG"
out returnType);
#line 1198 "VBNET.ATG"
endPos = t.EndLocation;
}
Expect(1);
Block(
#line 1200 "VBNET.ATG"
out stmt);
Expect(100);
Expect(158);
EndOfStmt();
#line 1202 "VBNET.ATG"
OperatorDeclaration operatorDeclaration = new OperatorDeclaration {
Modifier = m.Modifier,
Attributes = attributes,
Parameters = parameters,
TypeReference = returnType,
OverloadableOperator = operatorType,
ConversionType = opConversionType,
ReturnTypeAttributes = returnTypeAttributes,
Body = (BlockStatement)stmt,
StartLocation = m.GetDeclarationLocation(startPos),
EndLocation = endPos
};
operatorDeclaration.Body.StartLocation = startPos;
operatorDeclaration.Body.EndLocation = t.Location;
compilationUnit.AddChild(operatorDeclaration);
break;
}
default: SynErr(244); break;
}
}
public virtual object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data) {
Debug.Assert((declareDeclaration != null));
Debug.Assert((declareDeclaration.Attributes != null));
Debug.Assert((declareDeclaration.Parameters != null));
Debug.Assert((declareDeclaration.TypeReference != null));
for (int i = 0; i < declareDeclaration.Attributes.Count; i++) {
AttributeSection o = declareDeclaration.Attributes[i];
Debug.Assert(o != null);
nodeStack.Push(o);
o.AcceptVisitor(this, data);
o = (AttributeSection)nodeStack.Pop();
if (o == null)
declareDeclaration.Attributes.RemoveAt(i--);
else
declareDeclaration.Attributes[i] = o;
}
for (int i = 0; i < declareDeclaration.Parameters.Count; i++) {
ParameterDeclarationExpression o = declareDeclaration.Parameters[i];
Debug.Assert(o != null);
nodeStack.Push(o);
o.AcceptVisitor(this, data);
o = (ParameterDeclarationExpression)nodeStack.Pop();
if (o == null)
declareDeclaration.Parameters.RemoveAt(i--);
else
declareDeclaration.Parameters[i] = o;
}
nodeStack.Push(declareDeclaration.TypeReference);
declareDeclaration.TypeReference.AcceptVisitor(this, data);
declareDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
return null;
}
public virtual object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data) {
throw new global::System.NotImplementedException("DeclareDeclaration");
}