public override object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { for (int i = 0; i < arrayCreateExpression.Arguments.Count; i++) { arrayCreateExpression.Arguments[i] = Expression.AddInteger(arrayCreateExpression.Arguments[i], -1); } return base.VisitArrayCreateExpression(arrayCreateExpression, data); }
public override object VisitArrayCreateExpression(ArrayCreateExpression array, object data) { for(int i = 0; i < array.Arguments.Count; i++) { array.Arguments[i] = Deparenthesize(array.Arguments[i]); } return base.VisitArrayCreateExpression(array, data); }
public override object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { if (arrayCreateExpression.IsImplicitlyTyped) { return CreateResolveResult(arrayCreateExpression.ArrayInitializer); } else { return CreateTypeResolveResult(TypeVisitor.CreateReturnType(arrayCreateExpression.CreateType, resolver)); } }
public override object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { arrayCreateExpression.CreateType.Parent = arrayCreateExpression; arrayCreateExpression.ArrayInitializer.Parent = arrayCreateExpression; foreach (INode argument in arrayCreateExpression.Arguments) argument.Parent = arrayCreateExpression; return base.VisitArrayCreateExpression(arrayCreateExpression, data); }
public override object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { if (arrayCreateExpression.ArrayInitializer == null) { return new CodeArrayCreateExpression(ConvType(arrayCreateExpression.CreateType), arrayCreateExpression.Arguments[0].AcceptVisitor(this, data) as CodeExpression); } return new CodeArrayCreateExpression(ConvType(arrayCreateExpression.CreateType), GetExpressionList(arrayCreateExpression.ArrayInitializer.CreateExpressions)); }
public override object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { for (int i = 0; i < arrayCreateExpression.Arguments.Count; i++) { arrayCreateExpression.Arguments[i] = Expression.AddInteger(arrayCreateExpression.Arguments[i], 1); } if (arrayCreateExpression.ArrayInitializer.CreateExpressions.Count == 0) { arrayCreateExpression.ArrayInitializer = null; } return base.VisitArrayCreateExpression(arrayCreateExpression, data); }
private List<Statement> GetArrayInitStatements(ArrayCreateExpression arrayCreateExpression, string variableName, List<Expression> initializerList) { List<Statement> list = new List<Statement>(); for (int idx = 0; idx < initializerList.Count; idx++) { AssignmentExpression assignment = InitArrayStatement(arrayCreateExpression, variableName, ((CollectionInitializerExpression) initializerList[idx]).CreateExpressions, idx); ExpressionStatement expressionStatement = new ExpressionStatement(assignment); list.Add(expressionStatement); } return list; }
public virtual object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { Debug.Assert((arrayCreateExpression != null)); Debug.Assert((arrayCreateExpression.CreateType != null)); Debug.Assert((arrayCreateExpression.Arguments != null)); Debug.Assert((arrayCreateExpression.ArrayInitializer != null)); arrayCreateExpression.CreateType.AcceptVisitor(this, data); foreach (Expression o in arrayCreateExpression.Arguments) { Debug.Assert(o != null); o.AcceptVisitor(this, data); } return arrayCreateExpression.ArrayInitializer.AcceptVisitor(this, data); }
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); }
public virtual object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { Debug.Assert((arrayCreateExpression != null)); Debug.Assert((arrayCreateExpression.CreateType != null)); Debug.Assert((arrayCreateExpression.Arguments != null)); Debug.Assert((arrayCreateExpression.ArrayInitializer != null)); nodeStack.Push(arrayCreateExpression.CreateType); arrayCreateExpression.CreateType.AcceptVisitor(this, data); arrayCreateExpression.CreateType = ((TypeReference)(nodeStack.Pop())); for (int i = 0; i < arrayCreateExpression.Arguments.Count; i++) { Expression o = arrayCreateExpression.Arguments[i]; Debug.Assert(o != null); nodeStack.Push(o); o.AcceptVisitor(this, data); o = (Expression)nodeStack.Pop(); if (o == null) arrayCreateExpression.Arguments.RemoveAt(i--); else arrayCreateExpression.Arguments[i] = o; } nodeStack.Push(arrayCreateExpression.ArrayInitializer); arrayCreateExpression.ArrayInitializer.AcceptVisitor(this, data); arrayCreateExpression.ArrayInitializer = ((CollectionInitializerExpression)(nodeStack.Pop())); return null; }
void ObjectCreateExpression( #line 1935 "VBNET.ATG" out Expression oce) { #line 1937 "VBNET.ATG" TypeReference type = null; Expression initializer = null; List<Expression> arguments = null; ArrayList dimensions = null; oce = null; bool canBeNormal; bool canBeReDim; Expect(148); if (StartOf(7)) { NonArrayTypeName( #line 1945 "VBNET.ATG" out type, false); if (la.kind == 25) { lexer.NextToken(); NormalOrReDimArgumentList( #line 1946 "VBNET.ATG" out arguments, out canBeNormal, out canBeReDim); Expect(26); if (la.kind == 23 || #line 1947 "VBNET.ATG" la.kind == Tokens.OpenParenthesis) { if ( #line 1947 "VBNET.ATG" la.kind == Tokens.OpenParenthesis) { ArrayTypeModifiers( #line 1948 "VBNET.ATG" out dimensions); CollectionInitializer( #line 1949 "VBNET.ATG" out initializer); } else { CollectionInitializer( #line 1950 "VBNET.ATG" out initializer); } } #line 1952 "VBNET.ATG" if (canBeReDim && !canBeNormal && initializer == null) initializer = new CollectionInitializerExpression(); } } #line 1956 "VBNET.ATG" if (initializer == null) { oce = new ObjectCreateExpression(type, arguments); } else { if (dimensions == null) dimensions = new ArrayList(); dimensions.Insert(0, (arguments == null) ? 0 : Math.Max(arguments.Count - 1, 0)); type.RankSpecifier = (int[])dimensions.ToArray(typeof(int)); ArrayCreateExpression ace = new ArrayCreateExpression(type, initializer as CollectionInitializerExpression); ace.Arguments = arguments; oce = ace; } if (la.kind == 218) { #line 1970 "VBNET.ATG" NamedArgumentExpression memberInitializer = null; lexer.NextToken(); #line 1974 "VBNET.ATG" CollectionInitializerExpression memberInitializers = new CollectionInitializerExpression(); memberInitializers.StartLocation = la.Location; Expect(23); MemberInitializer( #line 1978 "VBNET.ATG" out memberInitializer); #line 1979 "VBNET.ATG" memberInitializers.CreateExpressions.Add(memberInitializer); while (la.kind == 12) { lexer.NextToken(); MemberInitializer( #line 1981 "VBNET.ATG" out memberInitializer); #line 1982 "VBNET.ATG" memberInitializers.CreateExpressions.Add(memberInitializer); } Expect(24); #line 1986 "VBNET.ATG" memberInitializers.EndLocation = t.Location; if(oce is ObjectCreateExpression) { ((ObjectCreateExpression)oce).ObjectInitializer = memberInitializers; } } }
public override object VisitReDimStatement(ReDimStatement reDimStatement, object data) { base.VisitReDimStatement(reDimStatement, data); if (resolver.CompilationUnit == null) return null; if (reDimStatement.ReDimClauses.Count != 1) return null; if (reDimStatement.IsPreserve) { if (reDimStatement.ReDimClauses[0].Arguments.Count > 1) { // multidimensional Redim Preserve // replace with: // MyArray = (int[,])Microsoft.VisualBasic.CompilerServices.Utils.CopyArray(MyArray, new int[dim1+1, dim2+1]); ResolveResult rr = Resolve(reDimStatement.ReDimClauses[0].TargetObject); if (rr != null && rr.ResolvedType != null && rr.ResolvedType.IsArrayReturnType) { ArrayCreateExpression ace = new ArrayCreateExpression(ConvertType(rr.ResolvedType)); foreach (Expression arg in reDimStatement.ReDimClauses[0].Arguments) { ace.Arguments.Add(Expression.AddInteger(arg, 1)); } ReplaceCurrentNode(new ExpressionStatement( new AssignmentExpression( reDimStatement.ReDimClauses[0].TargetObject, AssignmentOperatorType.Assign, new CastExpression( ace.CreateType, new InvocationExpression( MakeFieldReferenceExpression("Microsoft.VisualBasic.CompilerServices.Utils.CopyArray"), new List<Expression> { reDimStatement.ReDimClauses[0].TargetObject, ace } ), CastType.Cast ) ))); } } } else { // replace with array create expression ResolveResult rr = Resolve(reDimStatement.ReDimClauses[0].TargetObject); if (rr != null && rr.ResolvedType != null && rr.ResolvedType.IsArrayReturnType) { ArrayCreateExpression ace = new ArrayCreateExpression(ConvertType(rr.ResolvedType)); foreach (Expression arg in reDimStatement.ReDimClauses[0].Arguments) { ace.Arguments.Add(Expression.AddInteger(arg, 1)); } ReplaceCurrentNode(new ExpressionStatement( new AssignmentExpression(reDimStatement.ReDimClauses[0].TargetObject, AssignmentOperatorType.Assign, ace))); } } return null; }
void NewExpression( #line 2065 "cs.ATG" out Expression pexpr) { #line 2066 "cs.ATG" pexpr = null; List<Expression> parameters = new List<Expression>(); TypeReference type = null; Expression expr; Expect(89); if (StartOf(10)) { NonArrayType( #line 2073 "cs.ATG" out type); } if (la.kind == 16 || la.kind == 20) { if (la.kind == 20) { #line 2079 "cs.ATG" ObjectCreateExpression oce = new ObjectCreateExpression(type, parameters); lexer.NextToken(); #line 2080 "cs.ATG" if (type == null) Error("Cannot use an anonymous type with arguments for the constructor"); if (StartOf(25)) { Argument( #line 2081 "cs.ATG" out expr); #line 2081 "cs.ATG" SafeAdd(oce, parameters, expr); while (la.kind == 14) { lexer.NextToken(); Argument( #line 2082 "cs.ATG" out expr); #line 2082 "cs.ATG" SafeAdd(oce, parameters, expr); } } Expect(21); #line 2084 "cs.ATG" pexpr = oce; if (la.kind == 16) { CollectionOrObjectInitializer( #line 2085 "cs.ATG" out expr); #line 2085 "cs.ATG" oce.ObjectInitializer = (CollectionInitializerExpression)expr; } } else { #line 2086 "cs.ATG" ObjectCreateExpression oce = new ObjectCreateExpression(type, parameters); CollectionOrObjectInitializer( #line 2087 "cs.ATG" out expr); #line 2087 "cs.ATG" oce.ObjectInitializer = (CollectionInitializerExpression)expr; #line 2088 "cs.ATG" pexpr = oce; } } else if (la.kind == 18) { lexer.NextToken(); #line 2093 "cs.ATG" ArrayCreateExpression ace = new ArrayCreateExpression(type); /* we must not change RankSpecifier on the null type reference*/ if (ace.CreateType.IsNull) { ace.CreateType = new TypeReference(""); } pexpr = ace; int dims = 0; List<int> ranks = new List<int>(); if (la.kind == 14 || la.kind == 19) { while (la.kind == 14) { lexer.NextToken(); #line 2100 "cs.ATG" dims += 1; } Expect(19); #line 2101 "cs.ATG" ranks.Add(dims); dims = 0; while (la.kind == 18) { lexer.NextToken(); while (la.kind == 14) { lexer.NextToken(); #line 2102 "cs.ATG" ++dims; } Expect(19); #line 2102 "cs.ATG" ranks.Add(dims); dims = 0; } #line 2103 "cs.ATG" ace.CreateType.RankSpecifier = ranks.ToArray(); CollectionInitializer( #line 2104 "cs.ATG" out expr); #line 2104 "cs.ATG" ace.ArrayInitializer = (CollectionInitializerExpression)expr; } else if (StartOf(6)) { Expr( #line 2105 "cs.ATG" out expr); #line 2105 "cs.ATG" if (expr != null) parameters.Add(expr); while (la.kind == 14) { lexer.NextToken(); #line 2106 "cs.ATG" dims += 1; Expr( #line 2107 "cs.ATG" out expr); #line 2107 "cs.ATG" if (expr != null) parameters.Add(expr); } Expect(19); #line 2109 "cs.ATG" ranks.Add(dims); ace.Arguments = parameters; dims = 0; while (la.kind == 18) { lexer.NextToken(); while (la.kind == 14) { lexer.NextToken(); #line 2110 "cs.ATG" ++dims; } Expect(19); #line 2110 "cs.ATG" ranks.Add(dims); dims = 0; } #line 2111 "cs.ATG" ace.CreateType.RankSpecifier = ranks.ToArray(); if (la.kind == 16) { CollectionInitializer( #line 2112 "cs.ATG" out expr); #line 2112 "cs.ATG" ace.ArrayInitializer = (CollectionInitializerExpression)expr; } } else SynErr(211); } else SynErr(212); }
public override object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { if (arrayCreateExpression.IsImplicitlyTyped) { // Console.WriteLine (arrayCreateExpression.ArrayInitializer); return Resolve (arrayCreateExpression.ArrayInitializer); } return CreateResult (arrayCreateExpression.CreateType); }
void ObjectCreateExpression( #line 1860 "VBNET.ATG" out Expression oce) { #line 1862 "VBNET.ATG" TypeReference type = null; Expression initializer = null; List<Expression> arguments = null; ArrayList dimensions = null; oce = null; bool canBeNormal; bool canBeReDim; Expect(127); NonArrayTypeName( #line 1869 "VBNET.ATG" out type, false); if (la.kind == 24) { lexer.NextToken(); NormalOrReDimArgumentList( #line 1870 "VBNET.ATG" out arguments, out canBeNormal, out canBeReDim); Expect(25); if (la.kind == 22 || #line 1871 "VBNET.ATG" la.kind == Tokens.OpenParenthesis) { if ( #line 1871 "VBNET.ATG" la.kind == Tokens.OpenParenthesis) { ArrayTypeModifiers( #line 1872 "VBNET.ATG" out dimensions); CollectionInitializer( #line 1873 "VBNET.ATG" out initializer); } else { CollectionInitializer( #line 1874 "VBNET.ATG" out initializer); } } #line 1876 "VBNET.ATG" if (canBeReDim && !canBeNormal && initializer == null) initializer = new CollectionInitializerExpression(); } #line 1879 "VBNET.ATG" if (type == null) type = new TypeReference("Object"); // fallback type on parser errors if (initializer == null) { oce = new ObjectCreateExpression(type, arguments); } else { if (dimensions == null) dimensions = new ArrayList(); dimensions.Insert(0, (arguments == null) ? 0 : Math.Max(arguments.Count - 1, 0)); type.RankSpecifier = (int[])dimensions.ToArray(typeof(int)); ArrayCreateExpression ace = new ArrayCreateExpression(type, initializer as CollectionInitializerExpression); ace.Arguments = arguments; oce = ace; } }
private AssignmentExpression InitArrayStatement(ArrayCreateExpression arrayCreateExpression, string variableName, List<Expression> creatExpressions, int index) { IdentifierExpression identifierExpression = new IdentifierExpression(variableName); List<Expression> indexes = new List<Expression>(); indexes.Add(new PrimitiveExpression(index, index.ToString())); IndexerExpression left = new IndexerExpression(identifierExpression, indexes); string createType = arrayCreateExpression.CreateType.Type; ArrayCreateExpression right = new ArrayCreateExpression(new TypeReference(createType, new int[1])); right.ArrayInitializer = new CollectionInitializerExpression(creatExpressions); return new AssignmentExpression(left, AssignmentOperatorType.Assign, right); }
private string GetVariableName(ArrayCreateExpression arrayCreateExpression) { if (arrayCreateExpression.Parent is AssignmentExpression) { AssignmentExpression assignmentExpression = (AssignmentExpression) arrayCreateExpression.Parent; Expression left = assignmentExpression.Left; if (left is IdentifierExpression) return ((IdentifierExpression) left).Identifier; else return null; } else if (arrayCreateExpression.Parent is VariableDeclaration) { VariableDeclaration variableDeclaration = (VariableDeclaration) arrayCreateExpression.Parent; return variableDeclaration.Name; } else return null; }
public virtual bool VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object d) { if ((arrayCreateExpression == null)) { return SetFailure(); } if ((d == null)) { return SetFailure(); } if ((arrayCreateExpression.CreateType == null)) { return SetFailure(); } if ((arrayCreateExpression.Arguments == null)) { return SetFailure(); } if ((arrayCreateExpression.ArrayInitializer == null)) { return SetFailure(); } if(arrayCreateExpression.GetType() != d.GetType()) {return SetFailure();} var data = (ArrayCreateExpression)d; if (!IsMatch(arrayCreateExpression, data)) { return SetFailure(); } arrayCreateExpression.CreateType.AcceptVisitor(this, data.CreateType); if (arrayCreateExpression.Arguments.Count == data.Arguments.Count) { for (int i=0; i<arrayCreateExpression.Arguments.Count;i++) { Expression o = arrayCreateExpression.Arguments[i]; if(o == null){return SetFailure();} if((bool)o.AcceptVisitor(this, data.Arguments[i]) == false) return SetFailure(); } } else { return SetFailure(); } return arrayCreateExpression.ArrayInitializer.AcceptVisitor(this, data.ArrayInitializer); }
void VariableDeclaratorPartAfterIdentifier( #line 1341 "VBNET.ATG" List<VariableDeclaration> fieldDeclaration, string name) { #line 1343 "VBNET.ATG" Expression expr = null; TypeReference type = null; ArrayList rank = null; List<Expression> dimension = null; if ( #line 1348 "VBNET.ATG" IsSize() && !IsDims()) { ArrayInitializationModifier( #line 1348 "VBNET.ATG" out dimension); } if ( #line 1349 "VBNET.ATG" IsDims()) { ArrayNameModifier( #line 1349 "VBNET.ATG" out rank); } if ( #line 1351 "VBNET.ATG" IsObjectCreation()) { Expect(48); ObjectCreateExpression( #line 1351 "VBNET.ATG" out expr); #line 1353 "VBNET.ATG" if (expr is ObjectCreateExpression) { type = ((ObjectCreateExpression)expr).CreateType; } else { type = ((ArrayCreateExpression)expr).CreateType; } } else if (StartOf(21)) { if (la.kind == 48) { lexer.NextToken(); TypeName( #line 1360 "VBNET.ATG" out type); #line 1362 "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 1374 "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, 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 == 11) { lexer.NextToken(); VariableInitializer( #line 1397 "VBNET.ATG" out expr); } } else SynErr(232); #line 1399 "VBNET.ATG" fieldDeclaration.Add(new VariableDeclaration(name, expr, type)); }
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 virtual object TrackedVisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { return base.VisitArrayCreateExpression(arrayCreateExpression, data); }
public virtual object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { throw new global::System.NotImplementedException("ArrayCreateExpression"); }
public override object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { if (arrayCreateExpression.CreateType.RankSpecifier[0] != 0) throw new EvaluateException(arrayCreateExpression, "Multi-dimensional arrays are not suppored"); DebugType type = arrayCreateExpression.CreateType.ResolveType(context.AppDomain); int length = 0; if (arrayCreateExpression.Arguments.Count == 1) { length = EvaluateAsInt(arrayCreateExpression.Arguments[0]); } else if (!arrayCreateExpression.ArrayInitializer.IsNull) { length = arrayCreateExpression.ArrayInitializer.CreateExpressions.Count; } Value array = Eval.NewArray((DebugType)type.GetElementType(), (uint)length, null); if (!arrayCreateExpression.ArrayInitializer.IsNull) { List<Expression> inits = arrayCreateExpression.ArrayInitializer.CreateExpressions; if (inits.Count != length) throw new EvaluateException(arrayCreateExpression, "Incorrect initializer length"); for(int i = 0; i < length; i++) { TypedValue init = EvaluateAs(inits[i], (DebugType)type.GetElementType()); array.SetArrayElement(new int[] { i }, init.Value); } } return new TypedValue(array, type); }
public object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { throw new NotImplementedException (); }
public sealed override object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { this.BeginVisit(arrayCreateExpression); object result = this.TrackedVisitArrayCreateExpression(arrayCreateExpression, data); this.EndVisit(arrayCreateExpression); return result; }
public virtual object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { throw CreateException(arrayCreateExpression); }
public override object TrackedVisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { string typeName = this.GetTypeName(arrayCreateExpression.CreateType); if (arrayCreateExpression.ArrayInitializer.CreateExpressions.Count != 0) { this.Append(string.Concat("Array[", typeName, "]")); this.Append("(("); bool flag = true; foreach (Expression createExpression in arrayCreateExpression.ArrayInitializer.CreateExpressions) { if (!flag) { this.Append(", "); } else { flag = false; } createExpression.AcceptVisitor(this, data); } this.Append("))"); } else { this.Append(string.Concat("Array.CreateInstance(", typeName)); if (arrayCreateExpression.Arguments.Count <= 0) { this.Append(", 0)"); } else { foreach (Expression argument in arrayCreateExpression.Arguments) { this.Append(", "); argument.AcceptVisitor(this, data); } this.Append(")"); } } return null; }
bool IsArrayMissingTypeToCreate(ArrayCreateExpression arrayCreate) { if (arrayCreate != null) { return String.IsNullOrEmpty(arrayCreate.CreateType.Type); } return false; }
void ObjectCreateExpression( //#line 2123 "VBNET.ATG" out Expression oce) { //#line 2125 "VBNET.ATG" TypeReference type = null; CollectionInitializerExpression initializer = null; List<Expression> arguments = null; ArrayList dimensions = null; oce = null; Location startLocation = la.Location; bool canBeNormal; bool canBeReDim; Expect(162); if (StartOf(8)) { NonArrayTypeName( //#line 2134 "VBNET.ATG" out type, false); if (la.kind == 37) { lexer.NextToken(); NormalOrReDimArgumentList( //#line 2135 "VBNET.ATG" out arguments, out canBeNormal, out canBeReDim); Expect(38); if (la.kind == 35 || //#line 2136 "VBNET.ATG" la.kind == Tokens.OpenParenthesis) { if ( //#line 2136 "VBNET.ATG" la.kind == Tokens.OpenParenthesis) { ArrayTypeModifiers( //#line 2137 "VBNET.ATG" out dimensions); CollectionInitializer( //#line 2138 "VBNET.ATG" out initializer); } else { CollectionInitializer( //#line 2139 "VBNET.ATG" out initializer); } } //#line 2141 "VBNET.ATG" if (canBeReDim && !canBeNormal && initializer == null) initializer = new CollectionInitializerExpression(); } } //#line 2145 "VBNET.ATG" if (initializer == null) { oce = new ObjectCreateExpression(type, arguments); } else { if (dimensions == null) dimensions = new ArrayList(); dimensions.Insert(0, (arguments == null) ? 0 : Math.Max(arguments.Count - 1, 0)); type.RankSpecifier = (int[])dimensions.ToArray(typeof(int)); ArrayCreateExpression ace = new ArrayCreateExpression(type, initializer); ace.Arguments = arguments; oce = ace; } if (la.kind == 126 || la.kind == 233) { if (la.kind == 233) { //#line 2160 "VBNET.ATG" MemberInitializerExpression memberInitializer = null; Expression anonymousMember = null; lexer.NextToken(); //#line 2165 "VBNET.ATG" CollectionInitializerExpression memberInitializers = new CollectionInitializerExpression(); memberInitializers.StartLocation = la.Location; Expect(35); if (la.kind == 26 || la.kind == 147) { MemberInitializer( //#line 2170 "VBNET.ATG" out memberInitializer); //#line 2171 "VBNET.ATG" memberInitializers.CreateExpressions.Add(memberInitializer); } else if (StartOf(24)) { Expr( //#line 2172 "VBNET.ATG" out anonymousMember); //#line 2173 "VBNET.ATG" memberInitializers.CreateExpressions.Add(anonymousMember); } else SynErr(270); while (la.kind == 22) { lexer.NextToken(); if (la.kind == 26 || la.kind == 147) { MemberInitializer( //#line 2177 "VBNET.ATG" out memberInitializer); //#line 2178 "VBNET.ATG" memberInitializers.CreateExpressions.Add(memberInitializer); } else if (StartOf(24)) { Expr( //#line 2179 "VBNET.ATG" out anonymousMember); //#line 2180 "VBNET.ATG" memberInitializers.CreateExpressions.Add(anonymousMember); } else SynErr(271); } Expect(36); //#line 2185 "VBNET.ATG" memberInitializers.EndLocation = t.Location; if(oce is ObjectCreateExpression) { ((ObjectCreateExpression)oce).ObjectInitializer = memberInitializers; } } else { lexer.NextToken(); CollectionInitializer( //#line 2195 "VBNET.ATG" out initializer); //#line 2197 "VBNET.ATG" if(oce is ObjectCreateExpression) ((ObjectCreateExpression)oce).ObjectInitializer = initializer; } } //#line 2203 "VBNET.ATG" if (oce != null) { oce.StartLocation = startLocation; oce.EndLocation = t.EndLocation; } }
public override object TrackedVisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { string arrayType = GetTypeName(arrayCreateExpression.CreateType); if (arrayCreateExpression.ArrayInitializer.CreateExpressions.Count == 0) { Append("Array.CreateInstance(" + arrayType); if (arrayCreateExpression.Arguments.Count > 0) { foreach (Expression expression in arrayCreateExpression.Arguments) { Append(", "); expression.AcceptVisitor(this, data); } Append(")"); } else { Append(", 0)"); } } else { Append("Array[" + arrayType + "]"); // Add initializers. Append("(("); bool firstItem = true; foreach (Expression expression in arrayCreateExpression.ArrayInitializer.CreateExpressions) { if (firstItem) { firstItem = false; } else { Append(", "); } expression.AcceptVisitor(this, data); } Append("))"); } return null; }