public ForStatement (Statement initializer, Expression condition, Statement increment, BlockStatement body) { this.initializer = initializer; this.condition = condition; this.increment = increment; this.body = body; }
public TypedAssignExpression(Expression target, Expression expression) : base(target, expression) { this.ElementType = TypedTransformer.GetElementType(target); //TODO: do we need to check the assigning type? if so how can we do it without the actual type handles? //Helper.AreEqual(this.ElementType, TypedTransformer.GetElementType(expression), "'expression' argument must have the same element type as 'target' argument."); }
private void WriteExpression(Cecil.Decompiler.Ast.Expression expr) { Cecil.Decompiler.Languages.ILanguage csharpLang = Cecil.Decompiler.Languages.CSharp.GetLanguage( Cecil.Decompiler.Languages.CSharpVersion.V1); var writer = csharpLang.GetWriter(new Cecil.Decompiler.Languages.ColoredConsoleFormatter()); writer.Write(expr); }
ICodeNode BuildUnaryExpression (UnaryOperator @operator, Expression expression) { return new UnaryExpression (@operator, (Expression) Visit (expression)); }
public MethodReferenceExpression (Expression target, MethodReference method) { this.target = target; this.method = method; }
public ExpressionStatement (Expression expression) { this.expression = expression; }
public override void Write (Expression expression) { Visit (expression); }
public TypedBinaryExpression(BinaryOperator @operator, Expression left, Expression right) : base(@operator, left, right) { this.ElementType = TypedTransformer.GetElementType(left); Helper.AreEqual(this.ElementType, TypedTransformer.GetElementType(right), "left and right expressions do not have the same ElementType"); }
public AddressOfExpression (Expression expression) { this.expression = expression; }
bool VisitMethodInvocationExpression (Expression node) { var invocation_expression = node as MethodInvocationExpression; if (invocation_expression == null) return false; var method_reference_expression = invocation_expression.Method as MethodReferenceExpression; if (method_reference_expression == null) return false; // todo : use a resolver for method calls switch (state) { case State.Begin: if (method_reference_expression.Method.Name != "GetEnumerator") return false; this.source = method_reference_expression.Target; break; case State.WhileCondition: if (!IsCallOnEnumerator (method_reference_expression, "MoveNext")) return false; break; case State.WhileBody: if (!IsCallOnEnumerator (method_reference_expression, "get_Current")) return false; break; case State.IfBody: if (!IsCallOnEnumerator (method_reference_expression, "Dispose")) return false; break; } return true; }
bool VisitAssignExpression (Expression node) { var assign_expression = node as AssignExpression; if (assign_expression == null) return false; if (!VisitVariableReferenceExpression (assign_expression.Target)) return false; if (!VisitMethodInvocationExpression (assign_expression.Expression)) return false; return true; }
public AssignExpression (Expression target, Expression expression) { this.target = target; this.expression = expression; }
public ConditionExpression (Expression condition, Expression then, Expression @else) { this.condition = condition; this.then = then; this.@else = @else; }
ICodeNode BuildBinaryExpression (BinaryOperator binary_operator, Expression left, Expression right) { base.Visit (left); base.Visit (right); return new BinaryExpression (binary_operator, left, right); }
ICodeNode BuildUnaryExpression (UnaryOperator unary_operator, Expression expression) { base.Visit (expression); return new UnaryExpression (unary_operator, expression); }
public override void VisitWhileStatement (WhileStatement node) { switch (state) { case State.Initializer: if (!VariableMatcher.FindVariableInExpression (variable, node.Condition)) break; state = State.Condition; condition = node.Condition; var body = node.Body; if (body.Statements.Count == 0) break; Visit (body.Statements [body.Statements.Count - 1]); if (!Match) break; CreateForStatement (body); break; } Continue = false; }
bool VisitVariableReferenceExpression (Expression node) { var variable_reference_expression = node as VariableReferenceExpression; if (variable_reference_expression == null) return false; switch (state) { case State.Begin: this.enumerator = variable_reference_expression.Variable; break; case State.WhileBody: this.variable = variable_reference_expression.Variable as VariableDefinition; break; } return true; }
public MethodInvocationExpression (Expression method) { this.method = method; }
bool IsEnumerator (Expression node) { var variable_reference = node as VariableReferenceExpression; if (variable_reference == null || variable_reference.Variable != this.enumerator) return false; return true; }
public FieldReferenceExpression (Expression target, FieldReference field) { this.target = target; this.field = field; }
public ConditionCase (Expression condition, BlockStatement body) : base (body) { this.condition = condition; }
void Push (Expression expression) { expression_decompiler.Push (expression); }
public UnaryExpression (UnaryOperator @operator, Expression operand) { this.@operator = @operator; this.operand = operand; }
void WriteBetweenParenthesis (Expression expression) { WriteToken ("("); Visit (expression); WriteToken (")"); }
public CastExpression (Expression expression, TypeReference targetType) { this.expression = expression; this.targetType = targetType; }
public abstract void Write (Expression expression);
public IfStatement (Expression condition, BlockStatement then, BlockStatement @else) { this.condition = condition; this.then = then; this.@else = @else; }
public static bool FindVariableInExpression (VariableReference variable, Expression expression) { var matcher = new VariableMatcher (variable); matcher.Visit (expression); return matcher.Match; }
public PropertyReferenceExpression (Expression target, PropertyReference property) { this.target = target; this.property = property; }
ICodeNode BuildBinaryExpression (BinaryOperator @operator, Expression left, Expression right) { return new BinaryExpression (@operator, (Expression) Visit (left), (Expression) Visit (right)); }
public SwitchStatement (Expression expression) { this.expression = expression; }