public virtual Differences VisitLRExpression(LRExpression expr1, LRExpression expr2){ Differences differences = new Differences(expr1, expr2); if (expr1 == null || expr2 == null){ if (expr1 != expr2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++; return differences; } LRExpression changes = (LRExpression)expr2.Clone(); LRExpression deletions = (LRExpression)expr2.Clone(); LRExpression insertions = (LRExpression)expr2.Clone(); Differences diff = this.VisitExpression(expr1.Expression, expr2.Expression); if (diff == null){Debug.Assert(false); return differences;} changes.Expression = diff.Changes as Expression; deletions.Expression = diff.Deletions as Expression; insertions.Expression = diff.Insertions as Expression; Debug.Assert(diff.Changes == changes.Expression && diff.Deletions == deletions.Expression && diff.Insertions == insertions.Expression); differences.NumberOfDifferences += diff.NumberOfDifferences; differences.NumberOfSimilarities += diff.NumberOfSimilarities; if (differences.NumberOfDifferences == 0){ differences.Changes = null; differences.Deletions = null; differences.Insertions = null; }else{ differences.Changes = changes; differences.Deletions = deletions; differences.Insertions = insertions; } return differences; }
public virtual Expression VisitLRExpression(LRExpression expr, LRExpression changes, LRExpression deletions, LRExpression insertions){ this.UpdateSourceContext(expr, changes); if (expr == null) return changes; if (changes != null){ if (deletions == null || insertions == null) Debug.Assert(false); else{ } }else if (deletions != null) return null; return expr; }
public override Expression VisitUnaryExpression(UnaryExpression unaryExpression) { if (unaryExpression == null) return null; Expression opnd = null; switch (unaryExpression.NodeType) { case NodeType.AddressOf: opnd = unaryExpression.Operand = this.VisitExpression(unaryExpression.Operand); if (opnd != null && this.CheckFixed(opnd) && opnd.Type != null && !opnd.Type.IsUnmanaged) { this.HandleError(unaryExpression, Error.ManagedAddr, this.GetTypeName(opnd.Type)); return null; } break; case NodeType.OutAddress: case NodeType.RefAddress: { bool savedRefout = this.refOrOutAddress; this.refOrOutAddress = true; Expression e = unaryExpression.Operand = this.VisitTargetExpression(unaryExpression.Operand); this.refOrOutAddress = savedRefout; if (e == null) return null; else if (!this.AllowPropertiesIndexersAsRef) { Indexer eAsIndexer = e as Indexer; if (eAsIndexer != null && eAsIndexer.CorrespondingDefaultIndexedProperty != null) { this.HandleError(e, Error.NotAssignable); return null; } MemberBinding eAsMB = e as MemberBinding; if (eAsMB != null && eAsMB.BoundMember is Property) { this.HandleError(e, Error.NotAssignable); return null; } } if (unaryExpression.NodeType != NodeType.OutAddress) e = this.VisitExpression(e); if (e == null) return null; MemberBinding mb = e as MemberBinding; if (mb != null) { Field f = mb.BoundMember as Field; if (f != null) { if (f.IsVolatile) this.HandleError(unaryExpression.Operand, Error.VolatileByRef, this.GetMemberSignature(f)); } else if (mb.BoundMember is Property) e = new LRExpression(e); } else { Indexer indxr = e as Indexer; if (indxr != null && indxr.CorrespondingDefaultIndexedProperty != null) e = new LRExpression(e); } opnd = unaryExpression.Operand = e; break; } default: opnd = unaryExpression.Operand = this.VisitExpression(unaryExpression.Operand); break; } if (opnd == null) return null; switch (unaryExpression.NodeType) { //TODO: deal with SkipCheck and EnforceCheck case NodeType.DefaultValue: case NodeType.Sizeof: case NodeType.Typeof: if (opnd == null) return null; Literal lit = opnd as Literal; if (lit == null || !(lit.Value is TypeNode)) { Debug.Assert(false); return null; } if (unaryExpression.NodeType == NodeType.Sizeof) { TypeNode t = (TypeNode)lit.Value; if (!t.IsUnmanaged) { this.HandleError(unaryExpression.Operand, Error.ManagedAddr, this.GetTypeName(t)); if (!this.typeSystem.insideUnsafeCode) { this.HandleError(unaryExpression, Error.SizeofUnsafe, this.GetTypeName(t)); } return null; } } return unaryExpression; case NodeType.LogicalNot: { TypeNode t = unaryExpression.Type; if (t == null) return null; if (this.typeSystem.IsNullableType(t)) t = this.typeSystem.RemoveNullableWrapper(t); if (t != SystemTypes.Boolean) { this.HandleError(unaryExpression, Error.BadUnaryOp, "!", this.GetTypeName(t)); return null; } Expression e = this.typeSystem.ImplicitCoercion(unaryExpression.Operand, SystemTypes.Boolean, this.TypeViewer); if (e != null) unaryExpression.Operand = e; return unaryExpression; } case NodeType.Neg: { TypeNode t = this.typeSystem.Unwrap(opnd.Type); if (t == null) return null; if (this.typeSystem.IsNullableType(t)) t = this.typeSystem.RemoveNullableWrapper(t); if ((!t.IsPrimitiveNumeric && t != SystemTypes.Char && t != SystemTypes.Decimal) || t.TypeCode == TypeCode.UInt64) { this.HandleError(unaryExpression, Error.BadUnaryOp, "-", this.GetTypeName(t)); return null; } t = unaryExpression.Type; if (t == null) return null; opnd = this.typeSystem.TryImplicitCoercion(unaryExpression.Operand, t, this.TypeViewer); if (opnd != null) unaryExpression.Operand = opnd; if (this.typeSystem.checkOverflow && opnd != null && t.IsPrimitiveInteger) { BinaryExpression be = new BinaryExpression(Literal.Int32Zero, opnd, NodeType.Sub_Ovf); if (t.IsUnsignedPrimitiveNumeric) be.NodeType = NodeType.Sub_Ovf_Un; if (t.TypeCode == TypeCode.Int64 || t.TypeCode == TypeCode.UInt64) be.Operand1 = Literal.Int64Zero; be.Type = unaryExpression.Type; be.SourceContext = unaryExpression.SourceContext; return be; } goto default; } default: return unaryExpression; } }
public virtual Expression VisitLRExpression(LRExpression expr){ if (expr == null) return null; expr.Expression = this.VisitExpression(expr.Expression); return expr; }
public virtual void VisitLRExpression(LRExpression expr) { if (expr == null) return; this.VisitExpression(expr.Expression); }
public override Statement VisitAssignmentStatement(AssignmentStatement assignment) { if (assignment == null) return null; if (this.TypeInVariableContext(assignment.Source as Literal)) return null; if (this.insideMethodContract || this.insideAssertOrAssume || this.insideInvariant) { this.HandleError(assignment, Error.SideEffectsNotAllowedInContracts); return null; } Composition comp = assignment.Target as Composition; if (comp != null) { comp.Expression = this.VisitTargetExpression(comp.Expression); if (comp.Expression == null) return null; } else { bool savedMayReferenceThisAndBase = this.MayReferenceThisAndBase; MemberBinding mb = assignment.Target as MemberBinding; if (assignment.Operator == NodeType.Nop && mb != null && (mb.TargetObject is ImplicitThis || mb.TargetObject is This)) { this.MayReferenceThisAndBase = true; } assignment.Target = this.VisitTargetExpression(assignment.Target); this.MayReferenceThisAndBase = savedMayReferenceThisAndBase; if (assignment.Target == null) return null; } TypeNode t = assignment.Target.Type; if (t == null) assignment.Target.Type = t = SystemTypes.Object; Expression source = this.VisitExpression(assignment.Source); if (source == null) return null; Reference rt = t as Reference; NodeType oper = assignment.Operator; if (rt != null && oper != NodeType.CopyReference) t = rt.ElementType; if (oper != NodeType.Nop && oper != NodeType.CopyReference) { this.CheckForGetAccessor(assignment.Target); LRExpression e = new LRExpression(assignment.Target); assignment.Target = e; if (assignment.OperatorOverload == null) { BinaryExpression be = new BinaryExpression(e, source, assignment.Operator, t, assignment.SourceContext); if (assignment.UnifiedType != t && assignment.UnifiedType != null) be.Type = assignment.UnifiedType; Expression pop = new Expression(NodeType.Pop, be.Type); Pointer pt = t as Pointer; if (pt != null && (assignment.Operator == NodeType.Add || assignment.Operator == NodeType.Sub)) { if (pt.ElementType != SystemTypes.Int8 && pt.ElementType != SystemTypes.UInt8) { UnaryExpression sizeOf = new UnaryExpression(new Literal(pt.ElementType, SystemTypes.Type), NodeType.Sizeof, SystemTypes.UInt32); Expression elemSize = PureEvaluator.EvalUnaryExpression((Literal)sizeOf.Operand, sizeOf); if (elemSize == null) elemSize = sizeOf; TypeNode offsetType = SystemTypes.Int32; if (source.Type != null && source.Type.IsPrimitiveInteger) offsetType = source.Type; BinaryExpression offset = new BinaryExpression(source, elemSize, NodeType.Mul, offsetType, source.SourceContext); Literal offsetLit = PureEvaluator.TryEvalBinaryExpression(source as Literal, elemSize as Literal, offset, this.typeSystem); if (offsetLit == null) { if (offsetType == SystemTypes.Int32) offset.Operand1 = new UnaryExpression(source, NodeType.Conv_I); else offset.Operand2 = this.typeSystem.ExplicitCoercion(elemSize, offsetType, this.TypeViewer); source = offset; } else source = offsetLit; } source = this.typeSystem.ExplicitCoercion(source, pt, this.TypeViewer); be.Operand2 = source; assignment.Source = be; return assignment; } source = this.CoerceBinaryExpressionOperands(be, pop, source); if (source == null) return null; if (source == pop) source = e; else if (!(source is Literal)) { be.Operand1 = e; } } assignment.Operator = NodeType.Nop; if (!t.IsPrimitiveNumeric && t != SystemTypes.Char && t != SystemTypes.Boolean && assignment.OperatorOverload == null && (assignment.UnifiedType == null || !assignment.UnifiedType.IsPrimitiveNumeric) && oper != NodeType.AddEventHandler && oper != NodeType.RemoveEventHandler && !(t is DelegateNode && (source.NodeType == NodeType.Add || source.NodeType == NodeType.Sub)) && !(t is EnumNode)) { this.HandleError(assignment, Error.BadBinaryOps, this.GetOperatorSymbol(oper), this.GetTypeName(t), this.GetTypeName(assignment.Source.Type)); return null; } if (assignment.OperatorOverload != null) { if (assignment.OperatorOverload.Parameters == null || assignment.OperatorOverload.Parameters.Count < 2) { Debug.Assert(false); return null; } source = this.typeSystem.ImplicitCoercion(source, assignment.OperatorOverload.Parameters[1].Type, this.TypeViewer); ExpressionList arguments = new ExpressionList(e, source); source = new MethodCall(new MemberBinding(null, assignment.OperatorOverload), arguments, NodeType.Call, assignment.OperatorOverload.ReturnType); assignment.OperatorOverload = null; } } assignment.Source = this.typeSystem.ImplicitCoercion(source, t, this.TypeViewer); return assignment; }
public override Expression VisitLRExpression(LRExpression expr) { throw new ApplicationException("unimplemented"); }
public override Expression VisitLRExpression(LRExpression expr) { if (expr == null) return null; return base.VisitLRExpression((LRExpression)expr.Clone()); }
public virtual Expression VisitLRExpression(LRExpression expr1, LRExpression expr2) { if (expr1 == null) return null; if (expr2 == null) expr1.Expression = this.VisitExpression(expr1.Expression, null); else expr1.Expression = this.VisitExpression(expr1.Expression, expr2.Expression); return expr1; }
public override Expression VisitLRExpression(LRExpression expr){ if (expr == null) return null; Expression e = this.VisitExpression(expr.Expression); Reference eRef = e == null ? null : e.Type as Reference; if (eRef != null) return new AddressDereference(e, eRef.ElementType); return e; }