private ICodeNode ConvertNewArrayInit(MethodInvocationExpression invocation) { if (invocation.Arguments.Count != 2) { return(null); } ArrayCreationExpression arrayCreation = GenerateArrayCreationExpression(invocation.Arguments[0]); if (arrayCreation == null) { return(null); } ArrayCreationExpression initializerArray = Visit(invocation.Arguments[1]) as ArrayCreationExpression; if (initializerArray == null || initializerArray.Dimensions == null || initializerArray.Initializer == null || initializerArray.Initializer.Expressions == null || initializerArray.Initializer.Expressions.Count == 0) { return(null); } arrayCreation.Dimensions = initializerArray.Dimensions; arrayCreation.Initializer = initializerArray.Initializer; return(arrayCreation); }
private ICodeNode ConvertListBind(MethodInvocationExpression invocation) { MethodReference methodRef; if (invocation.Arguments.Count != 2 || !TryGetMethodReference((Expression)Visit(invocation.Arguments[0]), "System.Reflection.MethodInfo", out methodRef)) { return(null); } PropertyDefinition propertyDef = ResolveProperty(methodRef); if (propertyDef == null) { return(null); } ArrayCreationExpression listValues = Visit(invocation.Arguments[1]) as ArrayCreationExpression; if (listValues == null || listValues.Dimensions == null || listValues.Dimensions.Count != 1 || listValues.Initializer == null || listValues.Initializer.Expressions == null) { return(null); } listValues.Initializer.InitializerType = InitializerType.CollectionInitializer; listValues.Initializer.IsMultiLine = true; return(new BinaryExpression(BinaryOperator.Assign, new PropertyInitializerExpression(propertyDef, propertyDef.PropertyType), listValues.Initializer, this.typeSystem, null)); }
private ICodeNode ConvertListInit(MethodInvocationExpression invocation) { if (invocation.Arguments.Count != 2) { return(null); } ObjectCreationExpression creation = Visit(invocation.Arguments[0]) as ObjectCreationExpression; if (creation == null || creation.Initializer != null) { return(null); } ArrayCreationExpression initializerArray = Visit(invocation.Arguments[1]) as ArrayCreationExpression; if (initializerArray == null || initializerArray.Dimensions == null || initializerArray.Dimensions.Count != 1 || initializerArray.Initializer == null || initializerArray.Initializer.Expressions == null) { return(null); } creation.Initializer = new InitializerExpression(initializerArray.Initializer.Expression, InitializerType.CollectionInitializer); creation.Initializer.IsMultiLine = true; return(creation); }
public override void VisitArrayCreationExpression(ArrayCreationExpression node) { expressions.Push(ExpressionKind.None); Visit(node.Dimensions); expressions.Pop(); Visit(node.Initializer); }
private ICodeNode ConvertMemberInit(MethodInvocationExpression invocation) { if (invocation.Arguments.Count != 2) { return(null); } ObjectCreationExpression creation = Visit(invocation.Arguments[0]) as ObjectCreationExpression; if (creation == null || creation.Initializer != null) { return(null); } ArrayCreationExpression initializerArray = Visit(invocation.Arguments[1]) as ArrayCreationExpression; if (initializerArray == null || initializerArray.Dimensions == null || initializerArray.Dimensions.Count != 1 || initializerArray.Initializer == null || initializerArray.Initializer.Expressions == null || initializerArray.Initializer.Expressions.Any(expr => expr.CodeNodeType != CodeNodeType.BinaryExpression || !(expr as BinaryExpression).IsAssignmentExpression)) { return(null); } if (initializerArray.Initializer.Expressions.Count > 0) { creation.Initializer = new InitializerExpression(initializerArray.Initializer.Expression, InitializerType.ObjectInitializer); creation.Initializer.IsMultiLine = true; } return(creation); }
public override void VisitBinaryExpression(BinaryExpression node) { base.VisitBinaryExpression(node); if (node.Operator == BinaryOperator.Assign && node.Right.CodeNodeType == CodeNodeType.ArrayCreationExpression) { ArrayCreationExpression arrayCreation = node.Right as ArrayCreationExpression; bool isInitializerPresent = Utilities.IsInitializerPresent(arrayCreation.Initializer); if (node.Left.CodeNodeType == CodeNodeType.VariableDeclarationExpression) { VariableDeclarationExpression variableDeclaration = node.Left as VariableDeclarationExpression; node.Left = new ArrayVariableDeclarationExpression(variableDeclaration, arrayCreation.ElementType, arrayCreation.Dimensions.CloneExpressionsOnly(), isInitializerPresent, null); } if (node.Left.CodeNodeType == CodeNodeType.VariableReferenceExpression) { VariableReferenceExpression variableReference = node.Left as VariableReferenceExpression; node.Left = new ArrayVariableReferenceExpression(variableReference, arrayCreation.ElementType, arrayCreation.Dimensions.CloneExpressionsOnly(), isInitializerPresent, null); } if (node.Left.CodeNodeType == CodeNodeType.FieldReferenceExpression) { FieldReferenceExpression fieldReference = node.Left as FieldReferenceExpression; node.Left = new ArrayAssignmentFieldReferenceExpression(fieldReference, arrayCreation.ElementType, arrayCreation.Dimensions.CloneExpressionsOnly(), isInitializerPresent, null); } } }
public override INode VisitArrayCreationExpression(ArrayCreationExpression arrayCreationExpression) { return(new ArrayCreationExpression(arrayCreationExpression.Context, arrayCreationExpression.Children.Select(Visit)) { Type = arrayCreationExpression.Type }); }
private ICodeNode ConvertCall(MethodInvocationExpression node) { MethodReference methodRef; if (node.Arguments.Count < 2 || !TryGetMethodReference((Expression)Visit(node.Arguments[1]), "System.Reflection.MethodInfo", out methodRef)) { return(null); } Expression target = GetTarget(node.Arguments[0]); MethodInvocationExpression methodInvoke = new MethodInvocationExpression(new MethodReferenceExpression(target, methodRef, null), null); if (node.Arguments.Count == 3) { ArrayCreationExpression arguments = Visit(node.Arguments[2]) as ArrayCreationExpression; if (arguments == null || arguments.Dimensions.Count != 1 || arguments.Initializer == null || arguments.Initializer.Expressions == null || arguments.Initializer.Expressions.Count != methodRef.Parameters.Count) { return(null); } foreach (Expression argument in arguments.Initializer.Expressions) { methodInvoke.Arguments.Add(argument); } } return(methodInvoke); }
private void RecordVariableAssignment(ExpressionStatement node) { BinaryExpression assignment = node.Expression as BinaryExpression; VariableReference variable = (assignment.Left as VariableReferenceExpression).Variable; assignment.Right = (Expression)Visit(assignment.Right); Expression rightClone = assignment.Right.CloneExpressionOnly(); this.variableToValueMap[variable] = rightClone; HashSet <ExpressionStatement> statements; if (!this.variableToAssigingStatementsMap.TryGetValue(variable, out statements)) { statements = new HashSet <ExpressionStatement>(); this.variableToAssigingStatementsMap[variable] = statements; } statements.Add(node); ArrayCreationExpression arrayCreation = rightClone as ArrayCreationExpression; if (arrayCreation == null || arrayCreation.Dimensions == null || arrayCreation.Dimensions.Count != 1 || arrayCreation.Initializer != null && arrayCreation.Initializer.Expressions != null && arrayCreation.Initializer.Expressions.Count > 0) { return; } var blockExpression = new BlockExpression(null); arrayCreation.Initializer = new InitializerExpression(blockExpression, InitializerType.ArrayInitializer); this.variableToLastUninitializedIndex[variable] = 0; }
public override Ust Visit(ArrayCreationExpression arrayCreationExpression) { Ust result; if (arrayCreationExpression.Initializers?.All(i => i is StringLiteral) ?? false) { var value = new StringBuilder(); var textSpans = new List <TextSpan>(); foreach (StringLiteral stringLiteral in arrayCreationExpression.Initializers) { value.Append(stringLiteral.Text); textSpans.Add(stringLiteral.TextSpan); } result = new StringLiteral(value.ToString(), textSpans.Union()) { InitialTextSpans = textSpans }; } else { result = VisitChildren(arrayCreationExpression); } return(result); }
private ICodeNode ConvertLambda(MethodInvocationExpression invocation) { if (invocation.Arguments.Count != 2) { return(null); } ArrayCreationExpression arguments = Visit(invocation.Arguments[1]) as ArrayCreationExpression; if (arguments == null || arguments.Initializer == null || arguments.Initializer.Expressions == null || arguments.Initializer.Expressions.Any(element => element.CodeNodeType != CodeNodeType.ArgumentReferenceExpression)) { return(null); } List <ArgumentReferenceExpression> parameters = arguments.Initializer.Expressions.Cast <ArgumentReferenceExpression>().ToList(); bool hasAnonymousParameter = parameters.Any(param => param.Parameter.ParameterType.Resolve().IsAnonymous()); BlockStatement body = new BlockStatement(); body.AddStatement(new ExpressionStatement(new ShortFormReturnExpression((Expression)Visit(invocation.Arguments[0]), null))); return(new LambdaExpression(new ExpressionCollection(parameters.Select(param => new LambdaParameterExpression(param.Parameter, !hasAnonymousParameter, null))), body, false, false, parameters.Select(argRef => argRef.Parameter), true, null)); }
public void Convert_JavaArrayInitialization() { var sourceCodeRep = new MemoryCodeRepository( "class ArrayInitialization {\r\n" + "public void init() {\r\n" + "int[] arr1 = new int[] { 1, 2, 3 };\r\n" + "int[][] arr2 = new int[1][2];\r\n" + "int[][] arr3 = new int[1][];\r\n" + "}\r\n" + "}", "ArrayInitialization.java" ); var workflow = new Workflow(sourceCodeRep, stage: Stage.Ust) { IsSimplifyUst = false }; var workflowResult = workflow.Process(); var ust = workflowResult.Usts.First(); var intType = new TypeToken("int"); var arrayData = new List <Tuple <List <Expression>, List <Expression> > >(); // new int[] { 1, 2, 3 }; arrayData.Add(new Tuple <List <Expression>, List <Expression> >( Enumerable.Range(1, 3).Select(num => new IntLiteral(num)).ToList <Expression>(), new List <Expression> { new IntLiteral(0) } )); // new int[1][2]; arrayData.Add(new Tuple <List <Expression>, List <Expression> >( null, new List <Expression> { new IntLiteral(1), new IntLiteral(2) } )); // new int[1][]; arrayData.Add(new Tuple <List <Expression>, List <Expression> >( null, new List <Expression> { new IntLiteral(1), new IntLiteral(0) } )); for (var i = 0; i < arrayData.Count; i++) { var data = arrayData[i]; var arrayCreationExpression = new ArrayCreationExpression { Type = intType, Initializers = data.Item1, Sizes = data.Item2 }; bool exist = ust.AnyDescendant(node => node.Equals(arrayCreationExpression)); Assert.IsTrue(exist, "Test failed on " + i + " iteration."); } }
public override void VisitArrayCreationExpression(ArrayCreationExpression node) { this.expressions.Push(0); this.Visit(node.get_Dimensions()); dummyVar0 = this.expressions.Pop(); this.Visit(node.get_Initializer()); return; }
public override ICodeNode VisitArrayCreationExpression(ArrayCreationExpression node) { V_0 = this.removePIDStep.VisitArrayCreationExpression(node); if (V_0 != null) { return(V_0); } return(this.VisitArrayCreationExpression(node)); }
public override void VisitArrayCreationExpression(ArrayCreationExpression node) { WriteKeyword("new"); WriteSpace(); WriteReference(node.Type); WriteToken("["); Visit(node.Dimensions); WriteToken("]"); }
public override void VisitArrayCreationExpression(ArrayCreationExpression node) { if (state == SearchState.Propagation) { canBePropagated = false; return; } base.VisitArrayCreationExpression(node); }
public override void VisitArrayCreationExpression(ArrayCreationExpression node) { this.VisitArrayCreationExpression(node); if (node.get_Initializer() != null) { V_0 = node.get_ExpressionType().Resolve(); this.AddArrayInitializerCasts(V_0, node.get_Initializer().get_Expression()); } return; }
public override void OnNewarr(Instruction instruction) { var creation = new ArrayCreationExpression( (TypeReference)instruction.Operand, new BlockExpression()); creation.Dimensions.Add(Pop()); Push(creation); }
public override void VisitArrayCreationExpression(ArrayCreationExpression node) { if (this.state == ExpressionPropagationStep.ExpressionTreeVisitor.SearchState.Propagation) { this.canBePropagated = false; return; } this.VisitArrayCreationExpression(node); return; }
public override void VisitArrayCreationExpression(ArrayCreationExpression node) { base.VisitArrayCreationExpression(node); if (node.Initializer != null) { TypeDefinition arrayType = node.ExpressionType.Resolve(); AddArrayInitializerCasts(arrayType, node.Initializer.Expression); } }
static dynamic handle(ArrayCreationExpression v) { List <dynamic> items = new List <dynamic>(); foreach (var expr in v.Initializer.Expressions) { items.Add(handle_dyn(expr)); } return(items.ToArray()); }
public override ICodeNode VisitArrayCreationExpression(ArrayCreationExpression node) { ICodeNode newNode = removePIDStep.VisitArrayCreationExpression(node); if (newNode != null) { return(newNode); } return(base.VisitArrayCreationExpression(node)); }
public override Ust VisitStackAllocArrayCreationExpression(StackAllocArrayCreationExpressionSyntax node) { var arrayTypeSyntax = (ArrayTypeSyntax)node.Type; // TODO: Fix it var type = (TypeToken)base.Visit(node.Type); var sizes = arrayTypeSyntax.RankSpecifiers .SelectMany(rank => rank.Sizes.Select(s => (Expression)VisitAndReturnNullIfError(s))).ToArray(); var result = new ArrayCreationExpression(type, sizes, new Expression[0], node.GetTextSpan()); return(result); }
/// <summary> /// Generates the code for an <see cref="ArrayCreationExpression"/>. /// </summary> /// <param name="expression">The expression</param> /// <returns>A BaZic code</returns> private string GenerateArrayCreationExpression(ArrayCreationExpression expression) { var values = new List <string>(); foreach (var item in expression.Values) { values.Add(GenerateExpression(item)); } return($"NEW [{string.Join(", ", values)}]"); }
public override Ust VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node) { var type = new TypeToken(CommonUtils.Prefix + "object", node.NewKeyword.GetTextSpan()); var sizes = node.Commas.Select(c => new IntLiteral(0, c.GetTextSpan())).ToList(); sizes.Add(new IntLiteral(0, node.CloseBracketToken.GetTextSpan())); var result = new ArrayCreationExpression(type, sizes, new Expression[0], node.GetTextSpan()); return(result); }
private uint GetCreatedArraySize(ArrayCreationExpression arrayCreation) { if (arrayCreation.get_Dimensions().get_Count() != 1) { throw new ArgumentOutOfRangeException("Expected one dimentional array creation."); } V_0 = arrayCreation.get_Dimensions().get_Item(0) as LiteralExpression; if (V_0 == null) { throw new ArgumentOutOfRangeException("Expected constant-size array"); } return(this.GetIndexFromLiteralExpression(V_0)); }
public override Ust VisitArrayCreationExpression(ArrayCreationExpressionSyntax node) { var type = ConvertType(base.Visit(node.Type.ElementType)); List <Expression> sizes = node.Type.RankSpecifiers .SelectMany(rank => rank.Sizes.Select(s => (Expression)VisitAndReturnNullIfError(s))).ToList(); List <Expression> inits = node.Initializer != null ? node.Initializer.Expressions.Select(e => (Expression)VisitAndReturnNullIfError(e)).ToList() : null; var result = new ArrayCreationExpression(type, sizes, inits, node.GetTextSpan()); return(result); }
private TypeReference GetUseInArrayCreation(ArrayCreationExpression arrayCreationExpression, VariableReference variable) { V_0 = arrayCreationExpression.get_Dimensions().GetEnumerator(); try { while (V_0.MoveNext()) { V_1 = V_0.get_Current(); if (V_1 as VariableReferenceExpression == null || (object)(V_1 as VariableReferenceExpression).get_Variable() != (object)variable) { continue; } V_2 = this.typeSystem.get_Int32(); goto Label0; } } finally { if (V_0 != null) { V_0.Dispose(); } } V_0 = arrayCreationExpression.get_Initializer().get_Expressions().GetEnumerator(); try { while (V_0.MoveNext()) { V_3 = V_0.get_Current(); if (V_3 as VariableReferenceExpression == null || (object)(V_3 as VariableReferenceExpression).get_Variable() != (object)variable) { continue; } V_2 = arrayCreationExpression.get_ElementType(); goto Label0; } goto Label1; } finally { if (V_0 != null) { V_0.Dispose(); } } Label0: return(V_2); Label1: throw new ArgumentOutOfRangeException("Expression is not evaluated to any type."); }
private ICodeNode ConvertNewObject(MethodInvocationExpression invocation) { if (invocation.Arguments.Count < 1 || invocation.Arguments.Count > 3) { return(null); } Expression visitedFirst = (Expression)Visit(invocation.Arguments[0]); MethodReference constructorReference; if (!TryGetMethodReference(visitedFirst, "System.Reflection.ConstructorInfo", out constructorReference)) { if (invocation.Arguments.Count != 1 || visitedFirst.CodeNodeType != CodeNodeType.TypeOfExpression) { return(null); } return(new ObjectCreationExpression(null, (visitedFirst as TypeOfExpression).Type, null, null)); } ObjectCreationExpression creationExpression = new ObjectCreationExpression(constructorReference, constructorReference.DeclaringType, null, null); if (invocation.Arguments.Count == 1) { return(creationExpression); } ArrayCreationExpression argumentsArray = Visit(invocation.Arguments[1]) as ArrayCreationExpression; if (argumentsArray == null || argumentsArray.Dimensions.Count != 1 || argumentsArray.Initializer == null || argumentsArray.Initializer.Expressions == null || argumentsArray.Initializer.Expressions.Count != constructorReference.Parameters.Count) { return(null); } foreach (Expression argument in argumentsArray.Initializer.Expressions) { creationExpression.Arguments.Add(argument); } if (invocation.Arguments.Count == 2) { return(creationExpression); } Visit(invocation.Arguments[2]); return(creationExpression); }
private bool TryFillInitializer(ArrayCreationExpression expression, MemberHandleExpression values) { if (values.get_MemberReference() as FieldDefinition == null) { return(false); } V_0 = this.ConvertInitialValues((values.get_MemberReference() as FieldDefinition).get_InitialValue(), expression.get_ElementType().get_Name()); if (V_0 == null || !this.CheckElementsCount(V_0, expression.get_Dimensions())) { return(false); } this.RebuildDimensions(ref V_0, expression.get_Dimensions()); expression.get_Initializer().set_Expressions(V_0); return(true); }