public override BlockStatement ParseBlock() { lexer.NextToken(); compilationUnit = new CompilationUnit(); BlockStatement blockStmt = new BlockStatement(); blockStmt.StartLocation = la.Location; BlockStart(blockStmt); while (la.kind != Tokens.EOF) { Token oldLa = la; Statement(); if (la == oldLa) { // did not advance lexer position, we cannot parse this as a statement block return(null); } } BlockEnd(); // if lexer didn't return any tokens, use position of the EOF token in "la" blockStmt.EndLocation = (t ?? la).EndLocation; Expect(Tokens.EOF); blockStmt.AcceptVisitor(new SetParentVisitor(), null); return(blockStmt); }
void ReplaceAllFunctionAssignments(BlockStatement block, string functionName, TypeReference typeReference) { ReturnStatementForFunctionAssignment visitor = new ReturnStatementForFunctionAssignment(functionName); block.AcceptVisitor(visitor, null); if (visitor.expressionsToReplace.Count == 1 && !visitor.hasExit && IsAssignmentTo(block.Children.Last(), functionName)) { Expression returnValue = GetAssignmentFromStatement(block.Children.Last()).Right; block.Children.RemoveAt(block.Children.Count - 1); block.Return(returnValue); } else { if (visitor.expressionsToReplace.Count > 0) { foreach (var expr in visitor.expressionsToReplace) { expr.Identifier = FunctionReturnValueName; } Expression init; init = ExpressionBuilder.CreateDefaultValueForType(typeReference); block.Children.Insert(0, new LocalVariableDeclaration(new VariableDeclaration(FunctionReturnValueName, init, typeReference))); block.Children[0].Parent = block; block.Return(new IdentifierExpression(FunctionReturnValueName)); } } }
public void VisitBlockStatement_TypeofConstantsIncluded() { //-- arrange var block = new BlockStatement( new ReturnStatement { Expression = new ConstantExpression { Value = typeof(IDisposable) } }, new ReturnStatement { Expression = new ConstantExpression { Value = (TypeMember)typeof(IFormattable) } } ); var foundTypes = new HashSet <TypeMember>(); var visitor = new TypeReferenceStatementVisitor(foundTypes); //-- act block.AcceptVisitor(visitor); //-- assert foundTypes.Should().BeEquivalentTo(new TypeMember[] { typeof(IDisposable), typeof(IFormattable) }); }
private bool HasReferencesInSelection(ISelection selection, Variable variable) { FindReferenceVisitor frv = new FindReferenceVisitor(CSharpNameComparer, variable.Name, selection.StartPosition, selection.EndPosition); var statement = new BlockStatement(); statement.Children = selection.Nodes; statement.AcceptVisitor(frv, null); return(frv.Identifiers.Count > 0); }
public GLSLVisitor(BlockStatement block, DecompilerContext ctx) { var trans1 = new ReplaceMethodCallsWithOperators(ctx); var trans2 = new RenameLocals(); ((IAstTransform)trans1).Run(block); trans2.Run(block); Result = block.AcceptVisitor(this, 0).ToString(); Result += Environment.NewLine; }
public GlslVisitor(BlockStatement block, CustomAttribute attr, DecompilerContext ctx) : this() { _attr = attr; var trans1 = new ReplaceMethodCallsWithOperators(ctx); var trans2 = new RenameLocals(); ((IAstTransform)trans1).Run(block); trans2.Run(block); Result = block.AcceptVisitor(this, 0).ToString(); Result += Environment.NewLine; }
public override void VisitBlockStatement(BlockStatement blockStatement) { var assignmentAnalysis = new ConvertToConstantIssue.VariableUsageAnalyzation (ctx); var newVars = new List<Tuple<VariableInitializer, IVariable, VariableState>>(); blockStatement.AcceptVisitor(assignmentAnalysis); foreach (var variable in fieldStack.Pop()) { var state = assignmentAnalysis.GetStatus(variable.Item2); if (state == VariableState.Changed) continue; newVars.Add(new Tuple<VariableInitializer, IVariable, VariableState> (variable.Item1, variable.Item2, state)); } fieldStack.Push(newVars); }
public HlslVisitor(BlockStatement block, CustomAttribute attr, ResolveVisitor resolver, DecompilerContext ctx) : this() { _attr = attr; _resolver = resolver; _resolver.Scan(block); var trans1 = new ReplaceMethodCallsWithOperators(ctx); var trans2 = new RenameLocals(); ((IAstTransform)trans1).Run(block); trans2.Run(block); Result = block.AcceptVisitor(this, 0).ToString(); Result += Environment.NewLine; }
void processBody(BlockStatement bs, TBody tb) { tb.text = bs.GetText(); var ivisitor = new FindAllMemberReference(); bs.AcceptVisitor(ivisitor); var ilist = ivisitor.memberRefList; foreach (var expr in ilist) { var invoke = new TInvoke(); invoke.target = expr.Target.GetText(); invoke.member = expr.MemberName; invoke.type = GetTargetTypeString(expr); tb.invokes.Add(invoke); } }
public override void VisitBlockStatement(BlockStatement blockStatement) { base.VisitBlockStatement(blockStatement); if (blockStatement.Parent is EntityDeclaration || blockStatement.Parent is Accessor) { var assignmentAnalysis = new VariableUsageAnalyzation(ctx); var newVars = new List <Tuple <VariableInitializer, IVariable> >(); blockStatement.AcceptVisitor(assignmentAnalysis); foreach (var variable in fieldStack.Pop()) { if (assignmentAnalysis.GetStatus(variable.Item2) == VariableState.Changed) { continue; } newVars.Add(variable); } fieldStack.Push(newVars); } }
public void VisitBlockStatement_LocalVariableTypesIncluded() { //-- arrange var block = new BlockStatement( new VariableDeclarationStatement { Variable = new LocalVariable { Name = "x", Type = typeof(IDisposable) } } ); var foundTypes = new HashSet <TypeMember>(); var visitor = new TypeReferenceStatementVisitor(foundTypes); //-- act block.AcceptVisitor(visitor); //-- assert foundTypes.Should().BeEquivalentTo(new TypeMember[] { typeof(IDisposable) }); }
bool HandleAnonymousMethod(ObjectCreateExpression objectCreateExpression, Expression target, MethodReference methodRef) { if (!context.Settings.AnonymousMethods) { return(false); // anonymous method decompilation is disabled } if (target != null && !(target is IdentifierExpression || target is ThisReferenceExpression || target is NullReferenceExpression)) { return(false); // don't copy arbitrary expressions, deal with identifiers only } // Anonymous methods are defined in the same assembly MethodDefinition method = methodRef.ResolveWithinSameModule(); if (!IsAnonymousMethod(context, method)) { return(false); } // Create AnonymousMethodExpression and prepare parameters AnonymousMethodExpression ame = new AnonymousMethodExpression(); ame.CopyAnnotationsFrom(objectCreateExpression); // copy ILRanges etc. ame.RemoveAnnotations <MethodReference>(); // remove reference to delegate ctor ame.AddAnnotation(method); // add reference to anonymous method ame.Parameters.AddRange(AstBuilder.MakeParameters(method, isLambda: true)); ame.HasParameterList = true; // rename variables so that they don't conflict with the parameters: foreach (ParameterDeclaration pd in ame.Parameters) { EnsureVariableNameIsAvailable(objectCreateExpression, pd.Name); } // Decompile the anonymous method: DecompilerContext subContext = context.Clone(); subContext.CurrentMethod = method; subContext.CurrentMethodIsAsync = false; subContext.ReservedVariableNames.AddRange(currentlyUsedVariableNames); BlockStatement body = AstMethodBodyBuilder.CreateMethodBody(method, subContext, ame.Parameters); TransformationPipeline.RunTransformationsUntil(body, v => v is DelegateConstruction, subContext); body.AcceptVisitor(this, null); bool isLambda = false; if (ame.Parameters.All(p => p.ParameterModifier == ParameterModifier.None)) { isLambda = (body.Statements.Count == 1 && body.Statements.Single() is ReturnStatement); } // Remove the parameter list from an AnonymousMethodExpression if the original method had no names, // and the parameters are not used in the method body if (!isLambda && method.Parameters.All(p => string.IsNullOrEmpty(p.Name))) { var parameterReferencingIdentifiers = from ident in body.Descendants.OfType <IdentifierExpression>() let v = ident.Annotation <ILVariable>() where v != null && v.IsParameter && method.Parameters.Contains(v.OriginalParameter) select ident; if (!parameterReferencingIdentifiers.Any()) { ame.Parameters.Clear(); ame.HasParameterList = false; } } // Replace all occurrences of 'this' in the method body with the delegate's target: foreach (AstNode node in body.Descendants) { if (node is ThisReferenceExpression) { node.ReplaceWith(target.Clone()); } } Expression replacement; if (isLambda) { LambdaExpression lambda = new LambdaExpression(); lambda.CopyAnnotationsFrom(ame); ame.Parameters.MoveTo(lambda.Parameters); Expression returnExpr = ((ReturnStatement)body.Statements.Single()).Expression; returnExpr.Remove(); lambda.Body = returnExpr; replacement = lambda; } else { ame.Body = body; replacement = ame; } var expectedType = objectCreateExpression.Annotation <TypeInformation>().ExpectedType.Resolve(); if (expectedType != null && !expectedType.IsDelegate()) { var simplifiedDelegateCreation = (ObjectCreateExpression)objectCreateExpression.Clone(); simplifiedDelegateCreation.Arguments.Clear(); simplifiedDelegateCreation.Arguments.Add(replacement); replacement = simplifiedDelegateCreation; } objectCreateExpression.ReplaceWith(replacement); return(true); }
bool HandleAnonymousMethod(ObjectCreateExpression objectCreateExpression, Expression target, MethodReference methodRef) { if (!context.Settings.AnonymousMethods) { return(false); // anonymous method decompilation is disabled } // Anonymous methods are defined in the same assembly MethodDefinition method = methodRef.ResolveWithinSameModule(); if (!IsAnonymousMethod(context, method)) { return(false); } // Create AnonymousMethodExpression and prepare parameters AnonymousMethodExpression ame = new AnonymousMethodExpression(); ame.Parameters.AddRange(AstBuilder.MakeParameters(method.Parameters)); ame.HasParameterList = true; // Decompile the anonymous method: DecompilerContext subContext = context.Clone(); subContext.CurrentMethod = method; BlockStatement body = AstMethodBodyBuilder.CreateMethodBody(method, subContext, ame.Parameters); TransformationPipeline.RunTransformationsUntil(body, v => v is DelegateConstruction, subContext); body.AcceptVisitor(this, null); bool isLambda = false; if (ame.Parameters.All(p => p.ParameterModifier == ParameterModifier.None)) { isLambda = (body.Statements.Count == 1 && body.Statements.Single() is ReturnStatement); } // Remove the parameter list from an AnonymousMethodExpression if the original method had no names, // and the parameters are not used in the method body if (!isLambda && method.Parameters.All(p => string.IsNullOrEmpty(p.Name))) { var parameterReferencingIdentifiers = from ident in body.Descendants.OfType <IdentifierExpression>() let v = ident.Annotation <ILVariable>() where v != null && v.IsParameter && method.Parameters.Contains(v.OriginalParameter) select ident; if (!parameterReferencingIdentifiers.Any()) { ame.Parameters.Clear(); ame.HasParameterList = false; } } // Replace all occurrences of 'this' in the method body with the delegate's target: foreach (AstNode node in body.Descendants) { if (node is ThisReferenceExpression) { node.ReplaceWith(target.Clone()); } } if (isLambda) { LambdaExpression lambda = new LambdaExpression(); ame.Parameters.MoveTo(lambda.Parameters); Expression returnExpr = ((ReturnStatement)body.Statements.Single()).Expression; returnExpr.Remove(); lambda.Body = returnExpr; objectCreateExpression.ReplaceWith(lambda); } else { ame.Body = body; objectCreateExpression.ReplaceWith(ame); } return(true); }