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 override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data) { FixTypeReferenceCasing(variableDeclaration.TypeReference, variableDeclaration.StartLocation); return base.VisitVariableDeclaration(variableDeclaration, data); }