public static VariableDeclaration add_Variable(this BlockStatement blockDeclaration, string name, Expression expression, TypeReference typeReference)
{
var variableDeclaration = new VariableDeclaration(name, expression) {TypeReference = typeReference};
var localVariableDeclaration = new LocalVariableDeclaration(variableDeclaration);
blockDeclaration.append(localVariableDeclaration);
return variableDeclaration;
}
public override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
{
if (nameComparer.Equals(from, variableDeclaration.Name)) {
variableDeclaration.Name = to;
}
return base.VisitVariableDeclaration(variableDeclaration, data);
}
public override object VisitVariableDeclaration(ICSharpCode.NRefactory.Ast.VariableDeclaration variableDeclaration, object data)
{
if (!(variableDeclaration.Parent is LocalVariableDeclaration))
{
this.ReplaceCurrentNode(new ExpressionStatement(new AssignmentExpression(new IdentifierExpression(variableDeclaration.Name), AssignmentOperatorType.Assign, variableDeclaration.Initializer)));
}
return(base.VisitVariableDeclaration(variableDeclaration, data));
}
public override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
{
// process local variables only
if (fields.Contains(variableDeclaration)) {
return null;
}
curBlock.Add(variableDeclaration.Name);
return base.VisitVariableDeclaration(variableDeclaration, data);
}
public override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
{
var objectCreateExpression = variableDeclaration.Initializer as ObjectCreateExpression;
if (objectCreateExpression != null && objectCreateExpression.IsAnonymousType)
{
UnlockWith(variableDeclaration);
}
return base.VisitVariableDeclaration(variableDeclaration, data);
}
bool Contains(VariableDeclaration varDecl)
{
foreach (VariableDeclaration v in this.unneededVarDecls) {
if (v.Name == varDecl.Name) {
return true;
}
}
return false;
}
public override object VisitVariableDeclaration(ICSharpCode.NRefactory.Ast.VariableDeclaration variableDeclaration, object data)
{
if (variablesToGenerate.Any(v => v.Name == variableDeclaration.Name))
{
RemoveCurrentNode();
if (variableDeclaration.Initializer != null && !variableDeclaration.Initializer.IsNull)
{
// BlockStatement block = blocks.Peek ();
curStatementList.Peek().Add(new ExpressionStatement(new AssignmentExpression(new IdentifierExpression(variableDeclaration.Name), AssignmentOperatorType.Assign, variableDeclaration.Initializer)));
}
return(null);
}
return(base.VisitVariableDeclaration(variableDeclaration, data));
}
public override void GenerateCode(List<AbstractNode> nodes, IList items)
{
TypeReference intReference = new TypeReference("System.Int32");
MethodDeclaration method = new MethodDeclaration("GetHashCode", Modifiers.Public | Modifiers.Override, intReference, null, null);
Expression expr = CallGetHashCode(new IdentifierExpression(currentClass.Fields[0].Name));
for (int i = 1; i < currentClass.Fields.Count; i++) {
IdentifierExpression identifier = new IdentifierExpression(currentClass.Fields[i].Name);
expr = new BinaryOperatorExpression(expr, BinaryOperatorType.ExclusiveOr,
CallGetHashCode(identifier));
}
method.Body = new BlockStatement();
method.Body.AddChild(new ReturnStatement(expr));
nodes.Add(method);
TypeReference boolReference = new TypeReference("System.Boolean");
TypeReference objectReference = new TypeReference("System.Object");
method = new MethodDeclaration("Equals", Modifiers.Public | Modifiers.Override, boolReference, null, null);
method.Parameters.Add(new ParameterDeclarationExpression(objectReference, "obj"));
method.Body = new BlockStatement();
TypeReference currentType = ConvertType(currentClass.DefaultReturnType);
expr = new TypeOfIsExpression(new IdentifierExpression("obj"), currentType);
expr = new ParenthesizedExpression(expr);
expr = new UnaryOperatorExpression(expr, UnaryOperatorType.Not);
method.Body.AddChild(new IfElseStatement(expr, new ReturnStatement(new PrimitiveExpression(false, "false"))));
expr = new BinaryOperatorExpression(new ThisReferenceExpression(),
BinaryOperatorType.Equality,
new IdentifierExpression("obj"));
method.Body.AddChild(new IfElseStatement(expr, new ReturnStatement(new PrimitiveExpression(true, "true"))));
VariableDeclaration var = new VariableDeclaration("my" + currentClass.Name,
new CastExpression(currentType, new IdentifierExpression("obj"), CastType.Cast),
currentType);
method.Body.AddChild(new LocalVariableDeclaration(var));
expr = TestEquality(var.Name, currentClass.Fields[0]);
for (int i = 1; i < currentClass.Fields.Count; i++) {
expr = new BinaryOperatorExpression(expr, BinaryOperatorType.LogicalAnd,
TestEquality(var.Name, currentClass.Fields[i]));
}
method.Body.AddChild(new ReturnStatement(expr));
nodes.Add(method);
}
public override object TrackedVisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
{
BlockStatement blockStatement = (BlockStatement) AstUtil.GetParentOfType(variableDeclaration, typeof(BlockStatement));
if (blockStatement != null)
{
int hashCode = blockStatement.GetHashCode();
if (!(blockStatement.Parent is MethodDeclaration) && !localVariables.Contains(variableDeclaration.Name))
localVariables.Add(variableDeclaration.Name, variableDeclaration);
else if (HasConflict(variableDeclaration))
{
string newName = renamer.GetNewName(variableDeclaration.Name);
renamedVariables.Add(variableDeclaration.Name + "_" + hashCode, newName);
variableDeclaration.Name = newName;
}
}
return base.TrackedVisitVariableDeclaration(variableDeclaration, data);
}
protected static Statement CreateCaller(AttributedNode parent, MethodDeclaration method, VariableDeclaration returnVariable)
{
Statement caller;
InvocationExpression expr = new InvocationExpression(new IdentifierExpression(method.Name), CreateArgumentExpressions(method.Parameters));
if (method.TypeReference.Type != "System.Void") {
TypeReference parentType = GetParentReturnType(parent);
if (method.TypeReference == parentType)
caller = new ReturnStatement(expr);
else {
returnVariable.Initializer = expr;
caller = new LocalVariableDeclaration(returnVariable);
}
} else {
caller = new ExpressionStatement(expr);
}
return caller;
}
public override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
{
string[] foulwords= new string[]
{
"f**k", "shit", "crap", "bollocks"
};//if anyone wants to go nuts: feel free to add more :)
foreach (var foulword in foulwords)
{
if (System.Text.RegularExpressions.Regex.Matches(variableDeclaration.Name, foulword).Count > 0)
cursecount++;
}
if (cursecount>5)
UnlockWith(variableDeclaration);
return base.VisitVariableDeclaration(variableDeclaration, data);
}
public override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
{
string[] foulwords= new string[]
{
"meh","blah", "pft", "rrrr","blib","blab", "blub","lol","uhu","aaah"
};//if anyone wants to go nuts: feel free to add more :)
foreach (var foulword in foulwords)
{
if (System.Text.RegularExpressions.Regex.Matches(variableDeclaration.Name, foulword).Count > 0)
cursecount++;
}
if (cursecount>5)
UnlockWith(variableDeclaration);
return base.VisitVariableDeclaration(variableDeclaration, data);
}
public override object VisitFieldDeclaration(NRefactoryAST.FieldDeclaration fieldDeclaration, object data)
{
DomRegion region = GetRegion(fieldDeclaration.StartLocation, fieldDeclaration.EndLocation);
DefaultClass c = GetCurrentClass();
ModifierEnum modifier = ConvertModifier(fieldDeclaration.Modifier,
(c.ClassType == ClassType.Struct && this.IsVisualBasic)
? ModifierEnum.Public : ModifierEnum.Private);
string doku = GetDocumentation(region.BeginLine, fieldDeclaration.Attributes);
if (currentClass.Count > 0)
{
for (int i = 0; i < fieldDeclaration.Fields.Count; ++i)
{
NRefactoryAST.VariableDeclaration field = (NRefactoryAST.VariableDeclaration)fieldDeclaration.Fields[i];
IReturnType retType;
if (c.ClassType == ClassType.Enum)
{
retType = c.DefaultReturnType;
}
else
{
retType = CreateReturnType(fieldDeclaration.GetTypeForField(i));
if (!field.FixedArrayInitialization.IsNull)
{
retType = new ArrayReturnType(cu.ProjectContent, retType, 1);
}
}
DefaultField f = new DefaultField(retType, field.Name, modifier, region, c);
ConvertAttributes(fieldDeclaration, f);
f.Documentation = doku;
if (c.ClassType == ClassType.Enum)
{
f.Modifiers = ModifierEnum.Const | ModifierEnum.Public;
}
c.Fields.Add(f);
mapField(fieldDeclaration, f);
}
}
return(null);
}
public override object TrackedVisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data)
{
string variableName = GetVariableName(arrayCreateExpression);
List<Expression> initializerList = arrayCreateExpression.ArrayInitializer.CreateExpressions;
Expression replacedExpression = arrayCreateExpression;
if (initializerList.Count > 0 && initializerList[0] is CollectionInitializerExpression && data is InsertionBlockData)
{
ArrayCreateExpression replacedArrayCreateExpression = arrayCreateExpression;
replacedArrayCreateExpression.ArrayInitializer = null;
replacedArrayCreateExpression.Arguments.Add(new PrimitiveExpression(initializerList.Count, initializerList.Count.ToString()));
string arrayTypeName = arrayCreateExpression.CreateType.Type + "s";
Position position = Position.After;
if (variableName == null)
{
variableName = arrayTypeName;
position = Position.Before;
}
List<Statement> initStatements = GetArrayInitStatements(replacedArrayCreateExpression, variableName, initializerList);
InsertionBlockData insertionBlockData = (InsertionBlockData) data;
insertionBlockData.Block = (BlockStatement) AstUtil.GetParentOfType(replacedArrayCreateExpression, typeof(BlockStatement));
insertionBlockData.BlockChildIndex = GetBlockChildIndex(replacedArrayCreateExpression, position);
insertionBlockData.Statements = initStatements;
if (variableName == arrayTypeName)
{
IdentifierExpression identifierExpression = new IdentifierExpression(variableName);
replacedExpression = identifierExpression;
VariableDeclaration variableDeclaration = new VariableDeclaration(variableName, arrayCreateExpression);
LocalVariableDeclaration localVariable = new LocalVariableDeclaration(variableDeclaration);
localVariable.TypeReference = arrayCreateExpression.CreateType;
initStatements.Insert(0, localVariable);
}
ReplaceCurrentNode(replacedExpression);
}
return base.TrackedVisitArrayCreateExpression(arrayCreateExpression, data);
}
void ConvertField(TypeReference typeRef, VariableDeclaration variable, FieldDeclaration fieldDeclaration)
{
B.TypeMember m;
if (currentType is B.EnumDefinition) {
if (variable.Initializer.IsNull) {
m = new B.EnumMember(GetLexicalInfo(fieldDeclaration));
} else {
PrimitiveExpression p = variable.Initializer as PrimitiveExpression;
if (p == null || !(p.Value is int)) {
AddError(fieldDeclaration, "enum member initializer must be integer value");
return;
}
m = new B.EnumMember(GetLexicalInfo(fieldDeclaration), new B.IntegerLiteralExpression((int)p.Value));
}
} else {
m = new B.Field(GetLexicalInfo(fieldDeclaration), ConvertTypeReference(typeRef), ConvertExpression(variable.Initializer));
m.Modifiers = ConvertModifier(fieldDeclaration, B.TypeMemberModifiers.Private);
}
m.Name = variable.Name;
ConvertAttributes(fieldDeclaration.Attributes, m.Attributes);
if (currentType != null) currentType.Members.Add(m);
}
public override object TrackedVisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
{
// Resolving anything here only makes sense
// if this declaration actually has an initializer.
if (variableDeclaration.Initializer.IsNull) {
return base.TrackedVisitVariableDeclaration(variableDeclaration, data);
}
LocalVariableDeclaration localVariableDeclaration = data as LocalVariableDeclaration;
if (this.isLocalVariable && localVariableDeclaration != null) {
if (variableDeclaration.Name == this.resourceManagerMember.Name) {
// Make sure we got the right declaration by comparing the positions.
// Both must have the same start position.
if (localVariableDeclaration.StartLocation.X == this.resourceManagerMember.Region.BeginColumn && localVariableDeclaration.StartLocation.Y == this.resourceManagerMember.Region.BeginLine) {
#if DEBUG
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver found local variable declaration: "+localVariableDeclaration.ToString()+" at "+localVariableDeclaration.StartLocation.ToString());
#endif
data = true;
}
}
}
FieldDeclaration fieldDeclaration = data as FieldDeclaration;
if (!this.isLocalVariable && fieldDeclaration != null) {
// Make sure we got the right declaration by comparing the positions.
// Both must have the same start position.
if (variableDeclaration.Name == this.resourceManagerMember.Name &&
fieldDeclaration.StartLocation.X == this.resourceManagerMember.Region.BeginColumn && fieldDeclaration.StartLocation.Y == this.resourceManagerMember.Region.BeginLine) {
#if DEBUG
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver found field declaration: "+fieldDeclaration.ToString()+" at "+fieldDeclaration.StartLocation.ToString());
#endif
data = true;
} else {
// This field might be referred to by a property
// that we are looking for.
// This association is cached in the
// resourceManagerFieldAccessedByProperty field
// to improve performance.
this.TryResolveResourceManagerProperty();
if (this.resourceManagerFieldAccessedByProperty != null &&
fieldDeclaration.StartLocation.X == this.resourceManagerFieldAccessedByProperty.Region.BeginColumn &&
fieldDeclaration.StartLocation.Y == this.resourceManagerFieldAccessedByProperty.Region.BeginLine) {
#if DEBUG
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver found field declaration (via associated property): "+fieldDeclaration.ToString()+" at "+fieldDeclaration.StartLocation.ToString());
#endif
data = true;
}
}
}
return base.TrackedVisitVariableDeclaration(variableDeclaration, data);
}
public override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
{
if (this.CheckNode(variableDeclaration)) {
return null;
}
return base.VisitVariableDeclaration(variableDeclaration, data);
}
void LocalVariableDeclarator(
#line 1515 "cs.ATG"
out VariableDeclaration var) {
#line 1516 "cs.ATG"
Expression expr = null;
Identifier();
#line 1518 "cs.ATG"
var = new VariableDeclaration(t.val); var.StartLocation = t.Location;
if (la.kind == 3) {
lexer.NextToken();
VariableInitializer(
#line 1519 "cs.ATG"
out expr);
#line 1519 "cs.ATG"
var.Initializer = expr;
}
#line 1520 "cs.ATG"
var.EndLocation = t.EndLocation;
}
void VariableDeclarator(
#line 1310 "cs.ATG"
FieldDeclaration parentFieldDeclaration) {
#line 1311 "cs.ATG"
Expression expr = null;
Identifier();
#line 1313 "cs.ATG"
VariableDeclaration f = new VariableDeclaration(t.val); f.StartLocation = t.Location;
if (la.kind == 3) {
lexer.NextToken();
VariableInitializer(
#line 1314 "cs.ATG"
out expr);
#line 1314 "cs.ATG"
f.Initializer = expr;
}
#line 1315 "cs.ATG"
f.EndLocation = t.EndLocation; SafeAdd(parentFieldDeclaration, parentFieldDeclaration.Fields, f);
}
public sealed override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data) {
this.BeginVisit(variableDeclaration);
object result = this.TrackedVisitVariableDeclaration(variableDeclaration, data);
this.EndVisit(variableDeclaration);
return result;
}
public virtual object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data) {
throw new global::System.NotImplementedException("VariableDeclaration");
}
void ConstantDeclarator(
//#line 1438 "VBNET.ATG"
List<VariableDeclaration> constantDeclaration) {
//#line 1440 "VBNET.ATG"
Expression expr = null;
TypeReference type = null;
string name = String.Empty;
Location location;
Identifier();
//#line 1445 "VBNET.ATG"
name = t.val; location = t.Location;
if (la.kind == 63) {
lexer.NextToken();
TypeName(
//#line 1446 "VBNET.ATG"
out type);
}
Expect(20);
Expr(
//#line 1447 "VBNET.ATG"
out expr);
//#line 1449 "VBNET.ATG"
VariableDeclaration f = new VariableDeclaration(name, expr);
f.TypeReference = type;
f.StartLocation = location;
constantDeclaration.Add(f);
}
void EnumMemberDecl(
//#line 774 "VBNET.ATG"
out FieldDeclaration f) {
//#line 776 "VBNET.ATG"
Expression expr = null;List<AttributeSection> attributes = new List<AttributeSection>();
AttributeSection section = null;
VariableDeclaration varDecl = null;
while (la.kind == 40) {
AttributeSection(
//#line 780 "VBNET.ATG"
out section);
//#line 780 "VBNET.ATG"
attributes.Add(section);
}
Identifier();
//#line 783 "VBNET.ATG"
f = new FieldDeclaration(attributes);
varDecl = new VariableDeclaration(t.val);
f.Fields.Add(varDecl);
f.StartLocation = varDecl.StartLocation = t.Location;
if (la.kind == 20) {
lexer.NextToken();
Expr(
//#line 788 "VBNET.ATG"
out expr);
//#line 788 "VBNET.ATG"
varDecl.Initializer = expr;
}
//#line 789 "VBNET.ATG"
f.EndLocation = varDecl.EndLocation = t.EndLocation;
EndOfStmt();
}
void EnumMemberDecl(
#line 743 "VBNET.ATG"
out FieldDeclaration f) {
#line 745 "VBNET.ATG"
Expression expr = null;List<AttributeSection> attributes = new List<AttributeSection>();
AttributeSection section = null;
VariableDeclaration varDecl = null;
while (la.kind == 28) {
AttributeSection(
#line 749 "VBNET.ATG"
out section);
#line 749 "VBNET.ATG"
attributes.Add(section);
}
Identifier();
#line 752 "VBNET.ATG"
f = new FieldDeclaration(attributes);
varDecl = new VariableDeclaration(t.val);
f.Fields.Add(varDecl);
f.StartLocation = varDecl.StartLocation = t.Location;
if (la.kind == 10) {
lexer.NextToken();
Expr(
#line 757 "VBNET.ATG"
out expr);
#line 757 "VBNET.ATG"
varDecl.Initializer = expr;
}
EndOfStmt();
}
void ConstantDeclarator(
#line 1381 "VBNET.ATG"
List<VariableDeclaration> constantDeclaration) {
#line 1383 "VBNET.ATG"
Expression expr = null;
TypeReference type = null;
string name = String.Empty;
Location location;
Identifier();
#line 1388 "VBNET.ATG"
name = t.val; location = t.Location;
if (la.kind == 50) {
lexer.NextToken();
TypeName(
#line 1389 "VBNET.ATG"
out type);
}
Expect(10);
Expr(
#line 1390 "VBNET.ATG"
out expr);
#line 1392 "VBNET.ATG"
VariableDeclaration f = new VariableDeclaration(name, expr);
f.TypeReference = type;
f.StartLocation = location;
constantDeclaration.Add(f);
}
public LocalVariableDeclaration(VariableDeclaration declaration) : this(TypeReference.Null)
{
Variables.Add(declaration);
}
public virtual object TrackedVisitVariableDeclaration(VariableDeclaration variableDeclaration, object data) {
return base.VisitVariableDeclaration(variableDeclaration, data);
}
void StructMemberDecl(
#line 753 "cs.ATG"
ModifierList m, List<AttributeSection> attributes) {
#line 755 "cs.ATG"
string qualident = null;
TypeReference type;
Expression expr;
List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
BlockStatement stmt = null;
List<TemplateDefinition> templates = new List<TemplateDefinition>();
TypeReference explicitInterface = null;
bool isExtensionMethod = false;
if (la.kind == 60) {
#line 765 "cs.ATG"
m.Check(Modifiers.Constants);
lexer.NextToken();
#line 766 "cs.ATG"
Location startPos = t.Location;
Type(
#line 767 "cs.ATG"
out type);
Identifier();
#line 767 "cs.ATG"
FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier | Modifiers.Const);
fd.StartLocation = m.GetDeclarationLocation(startPos);
VariableDeclaration f = new VariableDeclaration(t.val);
f.StartLocation = t.Location;
f.TypeReference = type;
SafeAdd(fd, fd.Fields, f);
Expect(3);
Expr(
#line 774 "cs.ATG"
out expr);
#line 774 "cs.ATG"
f.Initializer = expr;
while (la.kind == 14) {
lexer.NextToken();
Identifier();
#line 775 "cs.ATG"
f = new VariableDeclaration(t.val);
f.StartLocation = t.Location;
f.TypeReference = type;
SafeAdd(fd, fd.Fields, f);
Expect(3);
Expr(
#line 780 "cs.ATG"
out expr);
#line 780 "cs.ATG"
f.EndLocation = t.EndLocation; f.Initializer = expr;
}
Expect(11);
#line 781 "cs.ATG"
fd.EndLocation = t.EndLocation; AddChild(fd);
} else if (
#line 785 "cs.ATG"
NotVoidPointer()) {
#line 785 "cs.ATG"
m.Check(Modifiers.PropertysEventsMethods);
Expect(123);
#line 786 "cs.ATG"
Location startPos = t.Location;
if (
#line 787 "cs.ATG"
IsExplicitInterfaceImplementation()) {
TypeName(
#line 788 "cs.ATG"
out explicitInterface, false);
#line 789 "cs.ATG"
if (la.kind != Tokens.Dot || Peek(1).kind != Tokens.This) {
qualident = TypeReference.StripLastIdentifierFromType(ref explicitInterface);
}
} else if (StartOf(18)) {
Identifier();
#line 792 "cs.ATG"
qualident = t.val;
} else SynErr(162);
if (la.kind == 23) {
TypeParameterList(
#line 795 "cs.ATG"
templates);
}
Expect(20);
if (la.kind == 111) {
lexer.NextToken();
#line 798 "cs.ATG"
isExtensionMethod = true; /* C# 3.0 */
}
if (StartOf(11)) {
FormalParameterList(
#line 799 "cs.ATG"
p);
}
Expect(21);
#line 800 "cs.ATG"
MethodDeclaration methodDeclaration = new MethodDeclaration {
Name = qualident,
Modifier = m.Modifier,
TypeReference = new TypeReference("System.Void", true),
Parameters = p,
Attributes = attributes,
StartLocation = m.GetDeclarationLocation(startPos),
EndLocation = t.EndLocation,
Templates = templates,
IsExtensionMethod = isExtensionMethod
};
if (explicitInterface != null)
SafeAdd(methodDeclaration, methodDeclaration.InterfaceImplementations, new InterfaceImplementation(explicitInterface, qualident));
AddChild(methodDeclaration);
BlockStart(methodDeclaration);
while (la.kind == 127) {
TypeParameterConstraintsClause(
#line 818 "cs.ATG"
templates);
}
if (la.kind == 16) {
Block(
#line 820 "cs.ATG"
out stmt);
} else if (la.kind == 11) {
lexer.NextToken();
} else SynErr(163);
#line 820 "cs.ATG"
BlockEnd();
methodDeclaration.Body = (BlockStatement)stmt;
} else if (la.kind == 69) {
#line 824 "cs.ATG"
m.Check(Modifiers.PropertysEventsMethods);
lexer.NextToken();
#line 826 "cs.ATG"
EventDeclaration eventDecl = new EventDeclaration {
Modifier = m.Modifier,
Attributes = attributes,
StartLocation = t.Location
};
AddChild(eventDecl);
BlockStart(eventDecl);
EventAddRegion addBlock = null;
EventRemoveRegion removeBlock = null;
Type(
#line 836 "cs.ATG"
out type);
#line 836 "cs.ATG"
eventDecl.TypeReference = type;
if (
#line 837 "cs.ATG"
IsExplicitInterfaceImplementation()) {
TypeName(
#line 838 "cs.ATG"
out explicitInterface, false);
#line 839 "cs.ATG"
qualident = TypeReference.StripLastIdentifierFromType(ref explicitInterface);
#line 840 "cs.ATG"
eventDecl.InterfaceImplementations.Add(new InterfaceImplementation(explicitInterface, qualident));
} else if (StartOf(18)) {
Identifier();
#line 842 "cs.ATG"
qualident = t.val;
if (la.kind == 3) {
lexer.NextToken();
Expr(
#line 843 "cs.ATG"
out expr);
#line 843 "cs.ATG"
eventDecl.Initializer = expr;
}
while (la.kind == 14) {
lexer.NextToken();
#line 847 "cs.ATG"
eventDecl.Name = qualident; eventDecl.EndLocation = t.EndLocation; BlockEnd();
#line 849 "cs.ATG"
eventDecl = new EventDeclaration {
Modifier = eventDecl.Modifier,
Attributes = eventDecl.Attributes,
StartLocation = eventDecl.StartLocation,
TypeReference = eventDecl.TypeReference.Clone()
};
AddChild(eventDecl);
BlockStart(eventDecl);
Identifier();
#line 858 "cs.ATG"
qualident = t.val;
if (la.kind == 3) {
lexer.NextToken();
Expr(
#line 859 "cs.ATG"
out expr);
#line 859 "cs.ATG"
eventDecl.Initializer = expr;
}
}
} else SynErr(164);
#line 862 "cs.ATG"
eventDecl.Name = qualident; eventDecl.EndLocation = t.EndLocation;
if (la.kind == 16) {
lexer.NextToken();
#line 863 "cs.ATG"
eventDecl.BodyStart = t.Location;
EventAccessorDecls(
#line 864 "cs.ATG"
out addBlock, out removeBlock);
Expect(17);
#line 865 "cs.ATG"
eventDecl.BodyEnd = t.EndLocation;
}
if (la.kind == 11) {
lexer.NextToken();
}
#line 868 "cs.ATG"
BlockEnd();
eventDecl.AddRegion = addBlock;
eventDecl.RemoveRegion = removeBlock;
} else if (
#line 874 "cs.ATG"
IdentAndLPar()) {
#line 874 "cs.ATG"
m.Check(Modifiers.Constructors | Modifiers.StaticConstructors);
Identifier();
#line 875 "cs.ATG"
string name = t.val; Location startPos = t.Location;
Expect(20);
if (StartOf(11)) {
#line 875 "cs.ATG"
m.Check(Modifiers.Constructors);
FormalParameterList(
#line 876 "cs.ATG"
p);
}
Expect(21);
#line 878 "cs.ATG"
ConstructorInitializer init = null;
if (la.kind == 9) {
#line 879 "cs.ATG"
m.Check(Modifiers.Constructors);
ConstructorInitializer(
#line 880 "cs.ATG"
out init);
}
#line 882 "cs.ATG"
ConstructorDeclaration cd = new ConstructorDeclaration(name, m.Modifier, p, init, attributes);
cd.StartLocation = startPos;
cd.EndLocation = t.EndLocation;
if (la.kind == 16) {
Block(
#line 887 "cs.ATG"
out stmt);
} else if (la.kind == 11) {
lexer.NextToken();
} else SynErr(165);
#line 887 "cs.ATG"
cd.Body = (BlockStatement)stmt; AddChild(cd);
} else if (la.kind == 70 || la.kind == 80) {
#line 890 "cs.ATG"
m.Check(Modifiers.Operators);
if (m.isNone) Error("at least one modifier must be set");
bool isImplicit = true;
Location startPos = Location.Empty;
if (la.kind == 80) {
lexer.NextToken();
#line 895 "cs.ATG"
startPos = t.Location;
} else {
lexer.NextToken();
#line 895 "cs.ATG"
isImplicit = false; startPos = t.Location;
}
Expect(92);
Type(
#line 896 "cs.ATG"
out type);
#line 896 "cs.ATG"
TypeReference operatorType = type;
Expect(20);
Type(
#line 897 "cs.ATG"
out type);
Identifier();
#line 897 "cs.ATG"
string varName = t.val;
Expect(21);
#line 898 "cs.ATG"
Location endPos = t.Location;
if (la.kind == 16) {
Block(
#line 899 "cs.ATG"
out stmt);
} else if (la.kind == 11) {
lexer.NextToken();
#line 899 "cs.ATG"
stmt = null;
} else SynErr(166);
#line 902 "cs.ATG"
List<ParameterDeclarationExpression> parameters = new List<ParameterDeclarationExpression>();
parameters.Add(new ParameterDeclarationExpression(type, varName));
OperatorDeclaration operatorDeclaration = new OperatorDeclaration {
Name = (isImplicit ? "op_Implicit" : "op_Explicit"),
Modifier = m.Modifier,
Attributes = attributes,
Parameters = parameters,
TypeReference = operatorType,
ConversionType = isImplicit ? ConversionType.Implicit : ConversionType.Explicit,
Body = (BlockStatement)stmt,
StartLocation = m.GetDeclarationLocation(startPos),
EndLocation = endPos
};
AddChild(operatorDeclaration);
} else if (StartOf(21)) {
TypeDecl(
#line 920 "cs.ATG"
m, attributes);
} else if (StartOf(10)) {
Type(
#line 922 "cs.ATG"
out type);
#line 922 "cs.ATG"
Location startPos = t.Location;
if (la.kind == 92) {
#line 924 "cs.ATG"
OverloadableOperatorType op;
m.Check(Modifiers.Operators);
if (m.isNone) Error("at least one modifier must be set");
lexer.NextToken();
OverloadableOperator(
#line 928 "cs.ATG"
out op);
#line 928 "cs.ATG"
TypeReference firstType, secondType = null; string secondName = null;
Expect(20);
#line 929 "cs.ATG"
Location firstStart = la.Location, secondStart = Location.Empty, secondEnd = Location.Empty;
Type(
#line 929 "cs.ATG"
out firstType);
Identifier();
#line 929 "cs.ATG"
string firstName = t.val; Location firstEnd = t.EndLocation;
if (la.kind == 14) {
lexer.NextToken();
#line 930 "cs.ATG"
secondStart = la.Location;
Type(
#line 930 "cs.ATG"
out secondType);
Identifier();
#line 930 "cs.ATG"
secondName = t.val; secondEnd = t.EndLocation;
} else if (la.kind == 21) {
} else SynErr(167);
#line 938 "cs.ATG"
Location endPos = t.Location;
Expect(21);
if (la.kind == 16) {
Block(
#line 939 "cs.ATG"
out stmt);
} else if (la.kind == 11) {
lexer.NextToken();
} else SynErr(168);
#line 941 "cs.ATG"
if (op == OverloadableOperatorType.Add && secondType == null)
op = OverloadableOperatorType.UnaryPlus;
if (op == OverloadableOperatorType.Subtract && secondType == null)
op = OverloadableOperatorType.UnaryMinus;
OperatorDeclaration operatorDeclaration = new OperatorDeclaration {
Modifier = m.Modifier,
Attributes = attributes,
TypeReference = type,
OverloadableOperator = op,
Name = GetReflectionNameForOperator(op),
Body = (BlockStatement)stmt,
StartLocation = m.GetDeclarationLocation(startPos),
EndLocation = endPos
};
SafeAdd(operatorDeclaration, operatorDeclaration.Parameters, new ParameterDeclarationExpression(firstType, firstName) { StartLocation = firstStart, EndLocation = firstEnd });
if (secondType != null) {
SafeAdd(operatorDeclaration, operatorDeclaration.Parameters, new ParameterDeclarationExpression(secondType, secondName) { StartLocation = secondStart, EndLocation = secondEnd });
}
AddChild(operatorDeclaration);
} else if (
#line 963 "cs.ATG"
IsVarDecl()) {
#line 964 "cs.ATG"
m.Check(Modifiers.Fields);
FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier);
fd.StartLocation = m.GetDeclarationLocation(startPos);
if (
#line 968 "cs.ATG"
m.Contains(Modifiers.Fixed)) {
VariableDeclarator(
#line 969 "cs.ATG"
fd);
Expect(18);
Expr(
#line 971 "cs.ATG"
out expr);
#line 971 "cs.ATG"
if (fd.Fields.Count > 0)
fd.Fields[fd.Fields.Count-1].FixedArrayInitialization = expr;
Expect(19);
while (la.kind == 14) {
lexer.NextToken();
VariableDeclarator(
#line 975 "cs.ATG"
fd);
Expect(18);
Expr(
#line 977 "cs.ATG"
out expr);
#line 977 "cs.ATG"
if (fd.Fields.Count > 0)
fd.Fields[fd.Fields.Count-1].FixedArrayInitialization = expr;
Expect(19);
}
} else if (StartOf(18)) {
VariableDeclarator(
#line 982 "cs.ATG"
fd);
while (la.kind == 14) {
lexer.NextToken();
VariableDeclarator(
#line 983 "cs.ATG"
fd);
}
} else SynErr(169);
Expect(11);
#line 985 "cs.ATG"
fd.EndLocation = t.EndLocation; AddChild(fd);
} else if (la.kind == 111) {
#line 988 "cs.ATG"
m.Check(Modifiers.Indexers);
lexer.NextToken();
Expect(18);
FormalParameterList(
#line 989 "cs.ATG"
p);
Expect(19);
#line 989 "cs.ATG"
Location endLocation = t.EndLocation;
Expect(16);
#line 990 "cs.ATG"
PropertyDeclaration indexer = new PropertyDeclaration(m.Modifier | Modifiers.Default, attributes, "Item", p);
indexer.StartLocation = startPos;
indexer.EndLocation = endLocation;
indexer.BodyStart = t.Location;
indexer.TypeReference = type;
PropertyGetRegion getRegion;
PropertySetRegion setRegion;
AccessorDecls(
#line 998 "cs.ATG"
out getRegion, out setRegion);
Expect(17);
#line 999 "cs.ATG"
indexer.BodyEnd = t.EndLocation;
indexer.GetRegion = getRegion;
indexer.SetRegion = setRegion;
AddChild(indexer);
} else if (
#line 1004 "cs.ATG"
IsIdentifierToken(la)) {
if (
#line 1005 "cs.ATG"
IsExplicitInterfaceImplementation()) {
TypeName(
#line 1006 "cs.ATG"
out explicitInterface, false);
#line 1007 "cs.ATG"
if (la.kind != Tokens.Dot || Peek(1).kind != Tokens.This) {
qualident = TypeReference.StripLastIdentifierFromType(ref explicitInterface);
}
} else if (StartOf(18)) {
Identifier();
#line 1010 "cs.ATG"
qualident = t.val;
} else SynErr(170);
#line 1012 "cs.ATG"
Location qualIdentEndLocation = t.EndLocation;
if (la.kind == 16 || la.kind == 20 || la.kind == 23) {
if (la.kind == 20 || la.kind == 23) {
#line 1016 "cs.ATG"
m.Check(Modifiers.PropertysEventsMethods);
if (la.kind == 23) {
TypeParameterList(
#line 1018 "cs.ATG"
templates);
}
Expect(20);
if (la.kind == 111) {
lexer.NextToken();
#line 1020 "cs.ATG"
isExtensionMethod = true;
}
if (StartOf(11)) {
FormalParameterList(
#line 1021 "cs.ATG"
p);
}
Expect(21);
#line 1023 "cs.ATG"
MethodDeclaration methodDeclaration = new MethodDeclaration {
Name = qualident,
Modifier = m.Modifier,
TypeReference = type,
Parameters = p,
Attributes = attributes
};
if (explicitInterface != null)
methodDeclaration.InterfaceImplementations.Add(new InterfaceImplementation(explicitInterface, qualident));
methodDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
methodDeclaration.EndLocation = t.EndLocation;
methodDeclaration.IsExtensionMethod = isExtensionMethod;
methodDeclaration.Templates = templates;
AddChild(methodDeclaration);
while (la.kind == 127) {
TypeParameterConstraintsClause(
#line 1038 "cs.ATG"
templates);
}
if (la.kind == 16) {
Block(
#line 1039 "cs.ATG"
out stmt);
} else if (la.kind == 11) {
lexer.NextToken();
} else SynErr(171);
#line 1039 "cs.ATG"
methodDeclaration.Body = (BlockStatement)stmt;
} else {
lexer.NextToken();
#line 1042 "cs.ATG"
PropertyDeclaration pDecl = new PropertyDeclaration(qualident, type, m.Modifier, attributes);
if (explicitInterface != null)
pDecl.InterfaceImplementations.Add(new InterfaceImplementation(explicitInterface, qualident));
pDecl.StartLocation = m.GetDeclarationLocation(startPos);
pDecl.EndLocation = qualIdentEndLocation;
pDecl.BodyStart = t.Location;
PropertyGetRegion getRegion;
PropertySetRegion setRegion;
AccessorDecls(
#line 1051 "cs.ATG"
out getRegion, out setRegion);
Expect(17);
#line 1053 "cs.ATG"
pDecl.GetRegion = getRegion;
pDecl.SetRegion = setRegion;
pDecl.BodyEnd = t.EndLocation;
AddChild(pDecl);
}
} else if (la.kind == 15) {
#line 1061 "cs.ATG"
m.Check(Modifiers.Indexers);
lexer.NextToken();
Expect(111);
Expect(18);
FormalParameterList(
#line 1062 "cs.ATG"
p);
Expect(19);
#line 1063 "cs.ATG"
PropertyDeclaration indexer = new PropertyDeclaration(m.Modifier | Modifiers.Default, attributes, "Item", p);
indexer.StartLocation = m.GetDeclarationLocation(startPos);
indexer.EndLocation = t.EndLocation;
indexer.TypeReference = type;
if (explicitInterface != null)
SafeAdd(indexer, indexer.InterfaceImplementations, new InterfaceImplementation(explicitInterface, "this"));
PropertyGetRegion getRegion;
PropertySetRegion setRegion;
Expect(16);
#line 1072 "cs.ATG"
Location bodyStart = t.Location;
AccessorDecls(
#line 1073 "cs.ATG"
out getRegion, out setRegion);
Expect(17);
#line 1074 "cs.ATG"
indexer.BodyStart = bodyStart;
indexer.BodyEnd = t.EndLocation;
indexer.GetRegion = getRegion;
indexer.SetRegion = setRegion;
AddChild(indexer);
} else SynErr(172);
} else SynErr(173);
} else SynErr(174);
}
public override object TrackedVisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
{
this.AppendIndented(string.Concat(variableDeclaration.Name, " = "));
variableDeclaration.Initializer.AcceptVisitor(this, data);
this.AppendLine();
return null;
}
void EnumMemberDecl(
#line 1183 "cs.ATG"
out FieldDeclaration f) {
#line 1185 "cs.ATG"
Expression expr = null;
List<AttributeSection> attributes = new List<AttributeSection>();
AttributeSection section = null;
VariableDeclaration varDecl = null;
while (la.kind == 18) {
AttributeSection(
#line 1191 "cs.ATG"
out section);
#line 1191 "cs.ATG"
attributes.Add(section);
}
Identifier();
#line 1192 "cs.ATG"
f = new FieldDeclaration(attributes);
varDecl = new VariableDeclaration(t.val);
f.Fields.Add(varDecl);
f.StartLocation = t.Location;
f.EndLocation = t.EndLocation;
if (la.kind == 3) {
lexer.NextToken();
Expr(
#line 1198 "cs.ATG"
out expr);
#line 1198 "cs.ATG"
varDecl.Initializer = expr;
}
}
void VariableDeclaratorPartAfterIdentifier(
//#line 1463 "VBNET.ATG"
List<VariableDeclaration> fieldDeclaration, string name) {
//#line 1465 "VBNET.ATG"
Expression expr = null;
TypeReference type = null;
ArrayList rank = null;
List<Expression> dimension = null;
Location startLocation = t.Location;
if (
//#line 1471 "VBNET.ATG"
IsSize() && !IsDims()) {
ArrayInitializationModifier(
//#line 1471 "VBNET.ATG"
out dimension);
}
if (
//#line 1472 "VBNET.ATG"
IsDims()) {
ArrayNameModifier(
//#line 1472 "VBNET.ATG"
out rank);
}
if (
//#line 1474 "VBNET.ATG"
IsObjectCreation()) {
Expect(63);
ObjectCreateExpression(
//#line 1474 "VBNET.ATG"
out expr);
//#line 1476 "VBNET.ATG"
if (expr is ObjectCreateExpression) {
type = ((ObjectCreateExpression)expr).CreateType.Clone();
} else {
type = ((ArrayCreateExpression)expr).CreateType.Clone();
}
} else if (StartOf(23)) {
if (la.kind == 63) {
lexer.NextToken();
TypeName(
//#line 1483 "VBNET.ATG"
out type);
//#line 1485 "VBNET.ATG"
if (type != null) {
for (int i = fieldDeclaration.Count - 1; i >= 0; i--) {
VariableDeclaration vd = fieldDeclaration[i];
if (vd.TypeReference.Type.Length > 0) break;
TypeReference newType = type.Clone();
newType.RankSpecifier = vd.TypeReference.RankSpecifier;
vd.TypeReference = newType;
}
}
}
//#line 1497 "VBNET.ATG"
if (type == null && (dimension != null || rank != null)) {
type = new TypeReference("");
}
if (dimension != null) {
if(type.RankSpecifier != null) {
Error("array rank only allowed one time");
} else {
if (rank == null) {
type.RankSpecifier = new int[] { dimension.Count - 1 };
} else {
rank.Insert(0, dimension.Count - 1);
type.RankSpecifier = (int[])rank.ToArray(typeof(int));
}
expr = new ArrayCreateExpression(type.Clone(), dimension);
}
} else if (rank != null) {
if(type.RankSpecifier != null) {
Error("array rank only allowed one time");
} else {
type.RankSpecifier = (int[])rank.ToArray(typeof(int));
}
}
if (la.kind == 20) {
lexer.NextToken();
Expr(
//#line 1520 "VBNET.ATG"
out expr);
}
} else SynErr(269);
//#line 1523 "VBNET.ATG"
VariableDeclaration varDecl = new VariableDeclaration(name, expr, type);
varDecl.StartLocation = startLocation;
varDecl.EndLocation = t.Location;
fieldDeclaration.Add(varDecl);
}
public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)
{
base.VisitMethodDeclaration(methodDeclaration, data); // visit parameters
methodDeclaration.Attributes.Clear();
methodDeclaration.Body = new BlockStatement();
methodDeclaration.Modifier = Modifiers.Public;
if (methodDeclaration.Parameters.Count > 0) {
ParameterDeclarationExpression lastParameter = methodDeclaration.Parameters[methodDeclaration.Parameters.Count - 1];
if (lastParameter.ParamModifier == ParameterModifiers.Out) {
methodDeclaration.TypeReference = lastParameter.TypeReference;
methodDeclaration.Parameters.RemoveAt(methodDeclaration.Parameters.Count - 1);
VariableDeclaration tmpVarDecl = new VariableDeclaration("tmp");
tmpVarDecl.TypeReference = methodDeclaration.TypeReference;
methodDeclaration.Body.AddChild(new LocalVariableDeclaration(tmpVarDecl));
IdentifierExpression tmpIdent = new IdentifierExpression("tmp");
InvocationExpression ie = CreateMethodCall(methodDeclaration);
ie.Arguments.Add(new DirectionExpression(FieldDirection.Out, tmpIdent));
methodDeclaration.Body.AddChild(new ExpressionStatement(ie));
methodDeclaration.Body.AddChild(new ReturnStatement(tmpIdent));
return null;
}
}
methodDeclaration.Body.AddChild(new ExpressionStatement(CreateMethodCall(methodDeclaration)));
return null;
}
public LocalVariableDeclaration(VariableDeclaration declaration) : this(TypeReference.Null)
{
Variables.Add(declaration);
}
public override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
{
FixTypeReferenceCasing(variableDeclaration.TypeReference, variableDeclaration.StartLocation);
return base.VisitVariableDeclaration(variableDeclaration, data);
}
