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;
}
